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(EricWF): This test takes 40+ minutes to build with Clang 3.8 under ASAN or MSAN. 19 // UNSUPPORTED: asan, msan 20 21 // TODO GLIBC uses a different string for positive and negative NAN numbers. 22 // XFAIL: linux-gnu 23 24 #include <locale> 25 #include <ios> 26 #include <cassert> 27 #include <streambuf> 28 #include <cmath> 29 #include "test_iterators.h" 30 31 typedef std::num_put<char, output_iterator<char*> > F; 32 33 class my_facet 34 : public F 35 { 36 public: 37 explicit my_facet(std::size_t refs = 0) 38 : F(refs) {} 39 }; 40 41 class my_numpunct 42 : public std::numpunct<char> 43 { 44 public: 45 my_numpunct() : std::numpunct<char>() {} 46 47 protected: 48 virtual char_type do_decimal_point() const {return ';';} 49 virtual char_type do_thousands_sep() const {return '_';} 50 virtual std::string do_grouping() const {return std::string("\1\2\3");} 51 }; 52 53 void test1() 54 { 55 char str[200]; 56 output_iterator<char*> iter; 57 std::locale lc = std::locale::classic(); 58 std::locale lg(lc, new my_numpunct); 59 const my_facet f(1); 60 { 61 long double v = +0.; 62 std::ios ios(0); 63 // %g 64 { 65 ios.precision(0); 66 { 67 nouppercase(ios); 68 { 69 noshowpos(ios); 70 { 71 noshowpoint(ios); 72 { 73 ios.imbue(lc); 74 { 75 ios.width(0); 76 { 77 iter = f.put(output_iterator<char*>(str), ios, '*', v); 78 std::string ex(str, iter.base()); 79 assert(ex == "0"); 80 assert(ios.width() == 0); 81 } 82 ios.width(25); 83 left(ios); 84 { 85 iter = f.put(output_iterator<char*>(str), ios, '*', v); 86 std::string ex(str, iter.base()); 87 assert(ex == "0************************"); 88 assert(ios.width() == 0); 89 } 90 ios.width(25); 91 right(ios); 92 { 93 iter = f.put(output_iterator<char*>(str), ios, '*', v); 94 std::string ex(str, iter.base()); 95 assert(ex == "************************0"); 96 assert(ios.width() == 0); 97 } 98 ios.width(25); 99 internal(ios); 100 { 101 iter = f.put(output_iterator<char*>(str), ios, '*', v); 102 std::string ex(str, iter.base()); 103 assert(ex == "************************0"); 104 assert(ios.width() == 0); 105 } 106 } 107 ios.imbue(lg); 108 { 109 ios.width(0); 110 { 111 iter = f.put(output_iterator<char*>(str), ios, '*', v); 112 std::string ex(str, iter.base()); 113 assert(ex == "0"); 114 assert(ios.width() == 0); 115 } 116 ios.width(25); 117 left(ios); 118 { 119 iter = f.put(output_iterator<char*>(str), ios, '*', v); 120 std::string ex(str, iter.base()); 121 assert(ex == "0************************"); 122 assert(ios.width() == 0); 123 } 124 ios.width(25); 125 right(ios); 126 { 127 iter = f.put(output_iterator<char*>(str), ios, '*', v); 128 std::string ex(str, iter.base()); 129 assert(ex == "************************0"); 130 assert(ios.width() == 0); 131 } 132 ios.width(25); 133 internal(ios); 134 { 135 iter = f.put(output_iterator<char*>(str), ios, '*', v); 136 std::string ex(str, iter.base()); 137 assert(ex == "************************0"); 138 assert(ios.width() == 0); 139 } 140 } 141 } 142 showpoint(ios); 143 { 144 ios.imbue(lc); 145 { 146 ios.width(0); 147 { 148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 149 std::string ex(str, iter.base()); 150 assert(ex == "0."); 151 assert(ios.width() == 0); 152 } 153 ios.width(25); 154 left(ios); 155 { 156 iter = f.put(output_iterator<char*>(str), ios, '*', v); 157 std::string ex(str, iter.base()); 158 assert(ex == "0.***********************"); 159 assert(ios.width() == 0); 160 } 161 ios.width(25); 162 right(ios); 163 { 164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 165 std::string ex(str, iter.base()); 166 assert(ex == "***********************0."); 167 assert(ios.width() == 0); 168 } 169 ios.width(25); 170 internal(ios); 171 { 172 iter = f.put(output_iterator<char*>(str), ios, '*', v); 173 std::string ex(str, iter.base()); 174 assert(ex == "***********************0."); 175 assert(ios.width() == 0); 176 } 177 } 178 ios.imbue(lg); 179 { 180 ios.width(0); 181 { 182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 183 std::string ex(str, iter.base()); 184 assert(ex == "0;"); 185 assert(ios.width() == 0); 186 } 187 ios.width(25); 188 left(ios); 189 { 190 iter = f.put(output_iterator<char*>(str), ios, '*', v); 191 std::string ex(str, iter.base()); 192 assert(ex == "0;***********************"); 193 assert(ios.width() == 0); 194 } 195 ios.width(25); 196 right(ios); 197 { 198 iter = f.put(output_iterator<char*>(str), ios, '*', v); 199 std::string ex(str, iter.base()); 200 assert(ex == "***********************0;"); 201 assert(ios.width() == 0); 202 } 203 ios.width(25); 204 internal(ios); 205 { 206 iter = f.put(output_iterator<char*>(str), ios, '*', v); 207 std::string ex(str, iter.base()); 208 assert(ex == "***********************0;"); 209 assert(ios.width() == 0); 210 } 211 } 212 } 213 } 214 showpos(ios); 215 { 216 noshowpoint(ios); 217 { 218 ios.imbue(lc); 219 { 220 ios.width(0); 221 { 222 iter = f.put(output_iterator<char*>(str), ios, '*', v); 223 std::string ex(str, iter.base()); 224 assert(ex == "+0"); 225 assert(ios.width() == 0); 226 } 227 ios.width(25); 228 left(ios); 229 { 230 iter = f.put(output_iterator<char*>(str), ios, '*', v); 231 std::string ex(str, iter.base()); 232 assert(ex == "+0***********************"); 233 assert(ios.width() == 0); 234 } 235 ios.width(25); 236 right(ios); 237 { 238 iter = f.put(output_iterator<char*>(str), ios, '*', v); 239 std::string ex(str, iter.base()); 240 assert(ex == "***********************+0"); 241 assert(ios.width() == 0); 242 } 243 ios.width(25); 244 internal(ios); 245 { 246 iter = f.put(output_iterator<char*>(str), ios, '*', v); 247 std::string ex(str, iter.base()); 248 assert(ex == "+***********************0"); 249 assert(ios.width() == 0); 250 } 251 } 252 ios.imbue(lg); 253 { 254 ios.width(0); 255 { 256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 257 std::string ex(str, iter.base()); 258 assert(ex == "+0"); 259 assert(ios.width() == 0); 260 } 261 ios.width(25); 262 left(ios); 263 { 264 iter = f.put(output_iterator<char*>(str), ios, '*', v); 265 std::string ex(str, iter.base()); 266 assert(ex == "+0***********************"); 267 assert(ios.width() == 0); 268 } 269 ios.width(25); 270 right(ios); 271 { 272 iter = f.put(output_iterator<char*>(str), ios, '*', v); 273 std::string ex(str, iter.base()); 274 assert(ex == "***********************+0"); 275 assert(ios.width() == 0); 276 } 277 ios.width(25); 278 internal(ios); 279 { 280 iter = f.put(output_iterator<char*>(str), ios, '*', v); 281 std::string ex(str, iter.base()); 282 assert(ex == "+***********************0"); 283 assert(ios.width() == 0); 284 } 285 } 286 } 287 showpoint(ios); 288 { 289 ios.imbue(lc); 290 { 291 ios.width(0); 292 { 293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 294 std::string ex(str, iter.base()); 295 assert(ex == "+0."); 296 assert(ios.width() == 0); 297 } 298 ios.width(25); 299 left(ios); 300 { 301 iter = f.put(output_iterator<char*>(str), ios, '*', v); 302 std::string ex(str, iter.base()); 303 assert(ex == "+0.**********************"); 304 assert(ios.width() == 0); 305 } 306 ios.width(25); 307 right(ios); 308 { 309 iter = f.put(output_iterator<char*>(str), ios, '*', v); 310 std::string ex(str, iter.base()); 311 assert(ex == "**********************+0."); 312 assert(ios.width() == 0); 313 } 314 ios.width(25); 315 internal(ios); 316 { 317 iter = f.put(output_iterator<char*>(str), ios, '*', v); 318 std::string ex(str, iter.base()); 319 assert(ex == "+**********************0."); 320 assert(ios.width() == 0); 321 } 322 } 323 ios.imbue(lg); 324 { 325 ios.width(0); 326 { 327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 328 std::string ex(str, iter.base()); 329 assert(ex == "+0;"); 330 assert(ios.width() == 0); 331 } 332 ios.width(25); 333 left(ios); 334 { 335 iter = f.put(output_iterator<char*>(str), ios, '*', v); 336 std::string ex(str, iter.base()); 337 assert(ex == "+0;**********************"); 338 assert(ios.width() == 0); 339 } 340 ios.width(25); 341 right(ios); 342 { 343 iter = f.put(output_iterator<char*>(str), ios, '*', v); 344 std::string ex(str, iter.base()); 345 assert(ex == "**********************+0;"); 346 assert(ios.width() == 0); 347 } 348 ios.width(25); 349 internal(ios); 350 { 351 iter = f.put(output_iterator<char*>(str), ios, '*', v); 352 std::string ex(str, iter.base()); 353 assert(ex == "+**********************0;"); 354 assert(ios.width() == 0); 355 } 356 } 357 } 358 } 359 } 360 uppercase(ios); 361 { 362 noshowpos(ios); 363 { 364 noshowpoint(ios); 365 { 366 ios.imbue(lc); 367 { 368 ios.width(0); 369 { 370 iter = f.put(output_iterator<char*>(str), ios, '*', v); 371 std::string ex(str, iter.base()); 372 assert(ex == "0"); 373 assert(ios.width() == 0); 374 } 375 ios.width(25); 376 left(ios); 377 { 378 iter = f.put(output_iterator<char*>(str), ios, '*', v); 379 std::string ex(str, iter.base()); 380 assert(ex == "0************************"); 381 assert(ios.width() == 0); 382 } 383 ios.width(25); 384 right(ios); 385 { 386 iter = f.put(output_iterator<char*>(str), ios, '*', v); 387 std::string ex(str, iter.base()); 388 assert(ex == "************************0"); 389 assert(ios.width() == 0); 390 } 391 ios.width(25); 392 internal(ios); 393 { 394 iter = f.put(output_iterator<char*>(str), ios, '*', v); 395 std::string ex(str, iter.base()); 396 assert(ex == "************************0"); 397 assert(ios.width() == 0); 398 } 399 } 400 ios.imbue(lg); 401 { 402 ios.width(0); 403 { 404 iter = f.put(output_iterator<char*>(str), ios, '*', v); 405 std::string ex(str, iter.base()); 406 assert(ex == "0"); 407 assert(ios.width() == 0); 408 } 409 ios.width(25); 410 left(ios); 411 { 412 iter = f.put(output_iterator<char*>(str), ios, '*', v); 413 std::string ex(str, iter.base()); 414 assert(ex == "0************************"); 415 assert(ios.width() == 0); 416 } 417 ios.width(25); 418 right(ios); 419 { 420 iter = f.put(output_iterator<char*>(str), ios, '*', v); 421 std::string ex(str, iter.base()); 422 assert(ex == "************************0"); 423 assert(ios.width() == 0); 424 } 425 ios.width(25); 426 internal(ios); 427 { 428 iter = f.put(output_iterator<char*>(str), ios, '*', v); 429 std::string ex(str, iter.base()); 430 assert(ex == "************************0"); 431 assert(ios.width() == 0); 432 } 433 } 434 } 435 showpoint(ios); 436 { 437 ios.imbue(lc); 438 { 439 ios.width(0); 440 { 441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 442 std::string ex(str, iter.base()); 443 assert(ex == "0."); 444 assert(ios.width() == 0); 445 } 446 ios.width(25); 447 left(ios); 448 { 449 iter = f.put(output_iterator<char*>(str), ios, '*', v); 450 std::string ex(str, iter.base()); 451 assert(ex == "0.***********************"); 452 assert(ios.width() == 0); 453 } 454 ios.width(25); 455 right(ios); 456 { 457 iter = f.put(output_iterator<char*>(str), ios, '*', v); 458 std::string ex(str, iter.base()); 459 assert(ex == "***********************0."); 460 assert(ios.width() == 0); 461 } 462 ios.width(25); 463 internal(ios); 464 { 465 iter = f.put(output_iterator<char*>(str), ios, '*', v); 466 std::string ex(str, iter.base()); 467 assert(ex == "***********************0."); 468 assert(ios.width() == 0); 469 } 470 } 471 ios.imbue(lg); 472 { 473 ios.width(0); 474 { 475 iter = f.put(output_iterator<char*>(str), ios, '*', v); 476 std::string ex(str, iter.base()); 477 assert(ex == "0;"); 478 assert(ios.width() == 0); 479 } 480 ios.width(25); 481 left(ios); 482 { 483 iter = f.put(output_iterator<char*>(str), ios, '*', v); 484 std::string ex(str, iter.base()); 485 assert(ex == "0;***********************"); 486 assert(ios.width() == 0); 487 } 488 ios.width(25); 489 right(ios); 490 { 491 iter = f.put(output_iterator<char*>(str), ios, '*', v); 492 std::string ex(str, iter.base()); 493 assert(ex == "***********************0;"); 494 assert(ios.width() == 0); 495 } 496 ios.width(25); 497 internal(ios); 498 { 499 iter = f.put(output_iterator<char*>(str), ios, '*', v); 500 std::string ex(str, iter.base()); 501 assert(ex == "***********************0;"); 502 assert(ios.width() == 0); 503 } 504 } 505 } 506 } 507 showpos(ios); 508 { 509 noshowpoint(ios); 510 { 511 ios.imbue(lc); 512 { 513 ios.width(0); 514 { 515 iter = f.put(output_iterator<char*>(str), ios, '*', v); 516 std::string ex(str, iter.base()); 517 assert(ex == "+0"); 518 assert(ios.width() == 0); 519 } 520 ios.width(25); 521 left(ios); 522 { 523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 524 std::string ex(str, iter.base()); 525 assert(ex == "+0***********************"); 526 assert(ios.width() == 0); 527 } 528 ios.width(25); 529 right(ios); 530 { 531 iter = f.put(output_iterator<char*>(str), ios, '*', v); 532 std::string ex(str, iter.base()); 533 assert(ex == "***********************+0"); 534 assert(ios.width() == 0); 535 } 536 ios.width(25); 537 internal(ios); 538 { 539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 540 std::string ex(str, iter.base()); 541 assert(ex == "+***********************0"); 542 assert(ios.width() == 0); 543 } 544 } 545 ios.imbue(lg); 546 { 547 ios.width(0); 548 { 549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 550 std::string ex(str, iter.base()); 551 assert(ex == "+0"); 552 assert(ios.width() == 0); 553 } 554 ios.width(25); 555 left(ios); 556 { 557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 558 std::string ex(str, iter.base()); 559 assert(ex == "+0***********************"); 560 assert(ios.width() == 0); 561 } 562 ios.width(25); 563 right(ios); 564 { 565 iter = f.put(output_iterator<char*>(str), ios, '*', v); 566 std::string ex(str, iter.base()); 567 assert(ex == "***********************+0"); 568 assert(ios.width() == 0); 569 } 570 ios.width(25); 571 internal(ios); 572 { 573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 574 std::string ex(str, iter.base()); 575 assert(ex == "+***********************0"); 576 assert(ios.width() == 0); 577 } 578 } 579 } 580 showpoint(ios); 581 { 582 ios.imbue(lc); 583 { 584 ios.width(0); 585 { 586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 587 std::string ex(str, iter.base()); 588 assert(ex == "+0."); 589 assert(ios.width() == 0); 590 } 591 ios.width(25); 592 left(ios); 593 { 594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 595 std::string ex(str, iter.base()); 596 assert(ex == "+0.**********************"); 597 assert(ios.width() == 0); 598 } 599 ios.width(25); 600 right(ios); 601 { 602 iter = f.put(output_iterator<char*>(str), ios, '*', v); 603 std::string ex(str, iter.base()); 604 assert(ex == "**********************+0."); 605 assert(ios.width() == 0); 606 } 607 ios.width(25); 608 internal(ios); 609 { 610 iter = f.put(output_iterator<char*>(str), ios, '*', v); 611 std::string ex(str, iter.base()); 612 assert(ex == "+**********************0."); 613 assert(ios.width() == 0); 614 } 615 } 616 ios.imbue(lg); 617 { 618 ios.width(0); 619 { 620 iter = f.put(output_iterator<char*>(str), ios, '*', v); 621 std::string ex(str, iter.base()); 622 assert(ex == "+0;"); 623 assert(ios.width() == 0); 624 } 625 ios.width(25); 626 left(ios); 627 { 628 iter = f.put(output_iterator<char*>(str), ios, '*', v); 629 std::string ex(str, iter.base()); 630 assert(ex == "+0;**********************"); 631 assert(ios.width() == 0); 632 } 633 ios.width(25); 634 right(ios); 635 { 636 iter = f.put(output_iterator<char*>(str), ios, '*', v); 637 std::string ex(str, iter.base()); 638 assert(ex == "**********************+0;"); 639 assert(ios.width() == 0); 640 } 641 ios.width(25); 642 internal(ios); 643 { 644 iter = f.put(output_iterator<char*>(str), ios, '*', v); 645 std::string ex(str, iter.base()); 646 assert(ex == "+**********************0;"); 647 assert(ios.width() == 0); 648 } 649 } 650 } 651 } 652 } 653 } 654 ios.precision(1); 655 { 656 nouppercase(ios); 657 { 658 noshowpos(ios); 659 { 660 noshowpoint(ios); 661 { 662 ios.imbue(lc); 663 { 664 ios.width(0); 665 { 666 iter = f.put(output_iterator<char*>(str), ios, '*', v); 667 std::string ex(str, iter.base()); 668 assert(ex == "0"); 669 assert(ios.width() == 0); 670 } 671 ios.width(25); 672 left(ios); 673 { 674 iter = f.put(output_iterator<char*>(str), ios, '*', v); 675 std::string ex(str, iter.base()); 676 assert(ex == "0************************"); 677 assert(ios.width() == 0); 678 } 679 ios.width(25); 680 right(ios); 681 { 682 iter = f.put(output_iterator<char*>(str), ios, '*', v); 683 std::string ex(str, iter.base()); 684 assert(ex == "************************0"); 685 assert(ios.width() == 0); 686 } 687 ios.width(25); 688 internal(ios); 689 { 690 iter = f.put(output_iterator<char*>(str), ios, '*', v); 691 std::string ex(str, iter.base()); 692 assert(ex == "************************0"); 693 assert(ios.width() == 0); 694 } 695 } 696 ios.imbue(lg); 697 { 698 ios.width(0); 699 { 700 iter = f.put(output_iterator<char*>(str), ios, '*', v); 701 std::string ex(str, iter.base()); 702 assert(ex == "0"); 703 assert(ios.width() == 0); 704 } 705 ios.width(25); 706 left(ios); 707 { 708 iter = f.put(output_iterator<char*>(str), ios, '*', v); 709 std::string ex(str, iter.base()); 710 assert(ex == "0************************"); 711 assert(ios.width() == 0); 712 } 713 ios.width(25); 714 right(ios); 715 { 716 iter = f.put(output_iterator<char*>(str), ios, '*', v); 717 std::string ex(str, iter.base()); 718 assert(ex == "************************0"); 719 assert(ios.width() == 0); 720 } 721 ios.width(25); 722 internal(ios); 723 { 724 iter = f.put(output_iterator<char*>(str), ios, '*', v); 725 std::string ex(str, iter.base()); 726 assert(ex == "************************0"); 727 assert(ios.width() == 0); 728 } 729 } 730 } 731 showpoint(ios); 732 { 733 ios.imbue(lc); 734 { 735 ios.width(0); 736 { 737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 738 std::string ex(str, iter.base()); 739 assert(ex == "0."); 740 assert(ios.width() == 0); 741 } 742 ios.width(25); 743 left(ios); 744 { 745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 746 std::string ex(str, iter.base()); 747 assert(ex == "0.***********************"); 748 assert(ios.width() == 0); 749 } 750 ios.width(25); 751 right(ios); 752 { 753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 754 std::string ex(str, iter.base()); 755 assert(ex == "***********************0."); 756 assert(ios.width() == 0); 757 } 758 ios.width(25); 759 internal(ios); 760 { 761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 762 std::string ex(str, iter.base()); 763 assert(ex == "***********************0."); 764 assert(ios.width() == 0); 765 } 766 } 767 ios.imbue(lg); 768 { 769 ios.width(0); 770 { 771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 772 std::string ex(str, iter.base()); 773 assert(ex == "0;"); 774 assert(ios.width() == 0); 775 } 776 ios.width(25); 777 left(ios); 778 { 779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 780 std::string ex(str, iter.base()); 781 assert(ex == "0;***********************"); 782 assert(ios.width() == 0); 783 } 784 ios.width(25); 785 right(ios); 786 { 787 iter = f.put(output_iterator<char*>(str), ios, '*', v); 788 std::string ex(str, iter.base()); 789 assert(ex == "***********************0;"); 790 assert(ios.width() == 0); 791 } 792 ios.width(25); 793 internal(ios); 794 { 795 iter = f.put(output_iterator<char*>(str), ios, '*', v); 796 std::string ex(str, iter.base()); 797 assert(ex == "***********************0;"); 798 assert(ios.width() == 0); 799 } 800 } 801 } 802 } 803 showpos(ios); 804 { 805 noshowpoint(ios); 806 { 807 ios.imbue(lc); 808 { 809 ios.width(0); 810 { 811 iter = f.put(output_iterator<char*>(str), ios, '*', v); 812 std::string ex(str, iter.base()); 813 assert(ex == "+0"); 814 assert(ios.width() == 0); 815 } 816 ios.width(25); 817 left(ios); 818 { 819 iter = f.put(output_iterator<char*>(str), ios, '*', v); 820 std::string ex(str, iter.base()); 821 assert(ex == "+0***********************"); 822 assert(ios.width() == 0); 823 } 824 ios.width(25); 825 right(ios); 826 { 827 iter = f.put(output_iterator<char*>(str), ios, '*', v); 828 std::string ex(str, iter.base()); 829 assert(ex == "***********************+0"); 830 assert(ios.width() == 0); 831 } 832 ios.width(25); 833 internal(ios); 834 { 835 iter = f.put(output_iterator<char*>(str), ios, '*', v); 836 std::string ex(str, iter.base()); 837 assert(ex == "+***********************0"); 838 assert(ios.width() == 0); 839 } 840 } 841 ios.imbue(lg); 842 { 843 ios.width(0); 844 { 845 iter = f.put(output_iterator<char*>(str), ios, '*', v); 846 std::string ex(str, iter.base()); 847 assert(ex == "+0"); 848 assert(ios.width() == 0); 849 } 850 ios.width(25); 851 left(ios); 852 { 853 iter = f.put(output_iterator<char*>(str), ios, '*', v); 854 std::string ex(str, iter.base()); 855 assert(ex == "+0***********************"); 856 assert(ios.width() == 0); 857 } 858 ios.width(25); 859 right(ios); 860 { 861 iter = f.put(output_iterator<char*>(str), ios, '*', v); 862 std::string ex(str, iter.base()); 863 assert(ex == "***********************+0"); 864 assert(ios.width() == 0); 865 } 866 ios.width(25); 867 internal(ios); 868 { 869 iter = f.put(output_iterator<char*>(str), ios, '*', v); 870 std::string ex(str, iter.base()); 871 assert(ex == "+***********************0"); 872 assert(ios.width() == 0); 873 } 874 } 875 } 876 showpoint(ios); 877 { 878 ios.imbue(lc); 879 { 880 ios.width(0); 881 { 882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 883 std::string ex(str, iter.base()); 884 assert(ex == "+0."); 885 assert(ios.width() == 0); 886 } 887 ios.width(25); 888 left(ios); 889 { 890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 891 std::string ex(str, iter.base()); 892 assert(ex == "+0.**********************"); 893 assert(ios.width() == 0); 894 } 895 ios.width(25); 896 right(ios); 897 { 898 iter = f.put(output_iterator<char*>(str), ios, '*', v); 899 std::string ex(str, iter.base()); 900 assert(ex == "**********************+0."); 901 assert(ios.width() == 0); 902 } 903 ios.width(25); 904 internal(ios); 905 { 906 iter = f.put(output_iterator<char*>(str), ios, '*', v); 907 std::string ex(str, iter.base()); 908 assert(ex == "+**********************0."); 909 assert(ios.width() == 0); 910 } 911 } 912 ios.imbue(lg); 913 { 914 ios.width(0); 915 { 916 iter = f.put(output_iterator<char*>(str), ios, '*', v); 917 std::string ex(str, iter.base()); 918 assert(ex == "+0;"); 919 assert(ios.width() == 0); 920 } 921 ios.width(25); 922 left(ios); 923 { 924 iter = f.put(output_iterator<char*>(str), ios, '*', v); 925 std::string ex(str, iter.base()); 926 assert(ex == "+0;**********************"); 927 assert(ios.width() == 0); 928 } 929 ios.width(25); 930 right(ios); 931 { 932 iter = f.put(output_iterator<char*>(str), ios, '*', v); 933 std::string ex(str, iter.base()); 934 assert(ex == "**********************+0;"); 935 assert(ios.width() == 0); 936 } 937 ios.width(25); 938 internal(ios); 939 { 940 iter = f.put(output_iterator<char*>(str), ios, '*', v); 941 std::string ex(str, iter.base()); 942 assert(ex == "+**********************0;"); 943 assert(ios.width() == 0); 944 } 945 } 946 } 947 } 948 } 949 uppercase(ios); 950 { 951 noshowpos(ios); 952 { 953 noshowpoint(ios); 954 { 955 ios.imbue(lc); 956 { 957 ios.width(0); 958 { 959 iter = f.put(output_iterator<char*>(str), ios, '*', v); 960 std::string ex(str, iter.base()); 961 assert(ex == "0"); 962 assert(ios.width() == 0); 963 } 964 ios.width(25); 965 left(ios); 966 { 967 iter = f.put(output_iterator<char*>(str), ios, '*', v); 968 std::string ex(str, iter.base()); 969 assert(ex == "0************************"); 970 assert(ios.width() == 0); 971 } 972 ios.width(25); 973 right(ios); 974 { 975 iter = f.put(output_iterator<char*>(str), ios, '*', v); 976 std::string ex(str, iter.base()); 977 assert(ex == "************************0"); 978 assert(ios.width() == 0); 979 } 980 ios.width(25); 981 internal(ios); 982 { 983 iter = f.put(output_iterator<char*>(str), ios, '*', v); 984 std::string ex(str, iter.base()); 985 assert(ex == "************************0"); 986 assert(ios.width() == 0); 987 } 988 } 989 ios.imbue(lg); 990 { 991 ios.width(0); 992 { 993 iter = f.put(output_iterator<char*>(str), ios, '*', v); 994 std::string ex(str, iter.base()); 995 assert(ex == "0"); 996 assert(ios.width() == 0); 997 } 998 ios.width(25); 999 left(ios); 1000 { 1001 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1002 std::string ex(str, iter.base()); 1003 assert(ex == "0************************"); 1004 assert(ios.width() == 0); 1005 } 1006 ios.width(25); 1007 right(ios); 1008 { 1009 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1010 std::string ex(str, iter.base()); 1011 assert(ex == "************************0"); 1012 assert(ios.width() == 0); 1013 } 1014 ios.width(25); 1015 internal(ios); 1016 { 1017 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1018 std::string ex(str, iter.base()); 1019 assert(ex == "************************0"); 1020 assert(ios.width() == 0); 1021 } 1022 } 1023 } 1024 showpoint(ios); 1025 { 1026 ios.imbue(lc); 1027 { 1028 ios.width(0); 1029 { 1030 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1031 std::string ex(str, iter.base()); 1032 assert(ex == "0."); 1033 assert(ios.width() == 0); 1034 } 1035 ios.width(25); 1036 left(ios); 1037 { 1038 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1039 std::string ex(str, iter.base()); 1040 assert(ex == "0.***********************"); 1041 assert(ios.width() == 0); 1042 } 1043 ios.width(25); 1044 right(ios); 1045 { 1046 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1047 std::string ex(str, iter.base()); 1048 assert(ex == "***********************0."); 1049 assert(ios.width() == 0); 1050 } 1051 ios.width(25); 1052 internal(ios); 1053 { 1054 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1055 std::string ex(str, iter.base()); 1056 assert(ex == "***********************0."); 1057 assert(ios.width() == 0); 1058 } 1059 } 1060 ios.imbue(lg); 1061 { 1062 ios.width(0); 1063 { 1064 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1065 std::string ex(str, iter.base()); 1066 assert(ex == "0;"); 1067 assert(ios.width() == 0); 1068 } 1069 ios.width(25); 1070 left(ios); 1071 { 1072 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1073 std::string ex(str, iter.base()); 1074 assert(ex == "0;***********************"); 1075 assert(ios.width() == 0); 1076 } 1077 ios.width(25); 1078 right(ios); 1079 { 1080 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1081 std::string ex(str, iter.base()); 1082 assert(ex == "***********************0;"); 1083 assert(ios.width() == 0); 1084 } 1085 ios.width(25); 1086 internal(ios); 1087 { 1088 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1089 std::string ex(str, iter.base()); 1090 assert(ex == "***********************0;"); 1091 assert(ios.width() == 0); 1092 } 1093 } 1094 } 1095 } 1096 showpos(ios); 1097 { 1098 noshowpoint(ios); 1099 { 1100 ios.imbue(lc); 1101 { 1102 ios.width(0); 1103 { 1104 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1105 std::string ex(str, iter.base()); 1106 assert(ex == "+0"); 1107 assert(ios.width() == 0); 1108 } 1109 ios.width(25); 1110 left(ios); 1111 { 1112 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1113 std::string ex(str, iter.base()); 1114 assert(ex == "+0***********************"); 1115 assert(ios.width() == 0); 1116 } 1117 ios.width(25); 1118 right(ios); 1119 { 1120 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1121 std::string ex(str, iter.base()); 1122 assert(ex == "***********************+0"); 1123 assert(ios.width() == 0); 1124 } 1125 ios.width(25); 1126 internal(ios); 1127 { 1128 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1129 std::string ex(str, iter.base()); 1130 assert(ex == "+***********************0"); 1131 assert(ios.width() == 0); 1132 } 1133 } 1134 ios.imbue(lg); 1135 { 1136 ios.width(0); 1137 { 1138 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1139 std::string ex(str, iter.base()); 1140 assert(ex == "+0"); 1141 assert(ios.width() == 0); 1142 } 1143 ios.width(25); 1144 left(ios); 1145 { 1146 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1147 std::string ex(str, iter.base()); 1148 assert(ex == "+0***********************"); 1149 assert(ios.width() == 0); 1150 } 1151 ios.width(25); 1152 right(ios); 1153 { 1154 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1155 std::string ex(str, iter.base()); 1156 assert(ex == "***********************+0"); 1157 assert(ios.width() == 0); 1158 } 1159 ios.width(25); 1160 internal(ios); 1161 { 1162 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1163 std::string ex(str, iter.base()); 1164 assert(ex == "+***********************0"); 1165 assert(ios.width() == 0); 1166 } 1167 } 1168 } 1169 showpoint(ios); 1170 { 1171 ios.imbue(lc); 1172 { 1173 ios.width(0); 1174 { 1175 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1176 std::string ex(str, iter.base()); 1177 assert(ex == "+0."); 1178 assert(ios.width() == 0); 1179 } 1180 ios.width(25); 1181 left(ios); 1182 { 1183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1184 std::string ex(str, iter.base()); 1185 assert(ex == "+0.**********************"); 1186 assert(ios.width() == 0); 1187 } 1188 ios.width(25); 1189 right(ios); 1190 { 1191 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1192 std::string ex(str, iter.base()); 1193 assert(ex == "**********************+0."); 1194 assert(ios.width() == 0); 1195 } 1196 ios.width(25); 1197 internal(ios); 1198 { 1199 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1200 std::string ex(str, iter.base()); 1201 assert(ex == "+**********************0."); 1202 assert(ios.width() == 0); 1203 } 1204 } 1205 ios.imbue(lg); 1206 { 1207 ios.width(0); 1208 { 1209 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1210 std::string ex(str, iter.base()); 1211 assert(ex == "+0;"); 1212 assert(ios.width() == 0); 1213 } 1214 ios.width(25); 1215 left(ios); 1216 { 1217 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1218 std::string ex(str, iter.base()); 1219 assert(ex == "+0;**********************"); 1220 assert(ios.width() == 0); 1221 } 1222 ios.width(25); 1223 right(ios); 1224 { 1225 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1226 std::string ex(str, iter.base()); 1227 assert(ex == "**********************+0;"); 1228 assert(ios.width() == 0); 1229 } 1230 ios.width(25); 1231 internal(ios); 1232 { 1233 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1234 std::string ex(str, iter.base()); 1235 assert(ex == "+**********************0;"); 1236 assert(ios.width() == 0); 1237 } 1238 } 1239 } 1240 } 1241 } 1242 } 1243 ios.precision(6); 1244 { 1245 nouppercase(ios); 1246 { 1247 noshowpos(ios); 1248 { 1249 noshowpoint(ios); 1250 { 1251 ios.imbue(lc); 1252 { 1253 ios.width(0); 1254 { 1255 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1256 std::string ex(str, iter.base()); 1257 assert(ex == "0"); 1258 assert(ios.width() == 0); 1259 } 1260 ios.width(25); 1261 left(ios); 1262 { 1263 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1264 std::string ex(str, iter.base()); 1265 assert(ex == "0************************"); 1266 assert(ios.width() == 0); 1267 } 1268 ios.width(25); 1269 right(ios); 1270 { 1271 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1272 std::string ex(str, iter.base()); 1273 assert(ex == "************************0"); 1274 assert(ios.width() == 0); 1275 } 1276 ios.width(25); 1277 internal(ios); 1278 { 1279 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1280 std::string ex(str, iter.base()); 1281 assert(ex == "************************0"); 1282 assert(ios.width() == 0); 1283 } 1284 } 1285 ios.imbue(lg); 1286 { 1287 ios.width(0); 1288 { 1289 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1290 std::string ex(str, iter.base()); 1291 assert(ex == "0"); 1292 assert(ios.width() == 0); 1293 } 1294 ios.width(25); 1295 left(ios); 1296 { 1297 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1298 std::string ex(str, iter.base()); 1299 assert(ex == "0************************"); 1300 assert(ios.width() == 0); 1301 } 1302 ios.width(25); 1303 right(ios); 1304 { 1305 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1306 std::string ex(str, iter.base()); 1307 assert(ex == "************************0"); 1308 assert(ios.width() == 0); 1309 } 1310 ios.width(25); 1311 internal(ios); 1312 { 1313 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1314 std::string ex(str, iter.base()); 1315 assert(ex == "************************0"); 1316 assert(ios.width() == 0); 1317 } 1318 } 1319 } 1320 showpoint(ios); 1321 { 1322 ios.imbue(lc); 1323 { 1324 ios.width(0); 1325 { 1326 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1327 std::string ex(str, iter.base()); 1328 assert(ex == "0.00000"); 1329 assert(ios.width() == 0); 1330 } 1331 ios.width(25); 1332 left(ios); 1333 { 1334 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1335 std::string ex(str, iter.base()); 1336 assert(ex == "0.00000******************"); 1337 assert(ios.width() == 0); 1338 } 1339 ios.width(25); 1340 right(ios); 1341 { 1342 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1343 std::string ex(str, iter.base()); 1344 assert(ex == "******************0.00000"); 1345 assert(ios.width() == 0); 1346 } 1347 ios.width(25); 1348 internal(ios); 1349 { 1350 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1351 std::string ex(str, iter.base()); 1352 assert(ex == "******************0.00000"); 1353 assert(ios.width() == 0); 1354 } 1355 } 1356 ios.imbue(lg); 1357 { 1358 ios.width(0); 1359 { 1360 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1361 std::string ex(str, iter.base()); 1362 assert(ex == "0;00000"); 1363 assert(ios.width() == 0); 1364 } 1365 ios.width(25); 1366 left(ios); 1367 { 1368 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1369 std::string ex(str, iter.base()); 1370 assert(ex == "0;00000******************"); 1371 assert(ios.width() == 0); 1372 } 1373 ios.width(25); 1374 right(ios); 1375 { 1376 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1377 std::string ex(str, iter.base()); 1378 assert(ex == "******************0;00000"); 1379 assert(ios.width() == 0); 1380 } 1381 ios.width(25); 1382 internal(ios); 1383 { 1384 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1385 std::string ex(str, iter.base()); 1386 assert(ex == "******************0;00000"); 1387 assert(ios.width() == 0); 1388 } 1389 } 1390 } 1391 } 1392 showpos(ios); 1393 { 1394 noshowpoint(ios); 1395 { 1396 ios.imbue(lc); 1397 { 1398 ios.width(0); 1399 { 1400 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1401 std::string ex(str, iter.base()); 1402 assert(ex == "+0"); 1403 assert(ios.width() == 0); 1404 } 1405 ios.width(25); 1406 left(ios); 1407 { 1408 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1409 std::string ex(str, iter.base()); 1410 assert(ex == "+0***********************"); 1411 assert(ios.width() == 0); 1412 } 1413 ios.width(25); 1414 right(ios); 1415 { 1416 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1417 std::string ex(str, iter.base()); 1418 assert(ex == "***********************+0"); 1419 assert(ios.width() == 0); 1420 } 1421 ios.width(25); 1422 internal(ios); 1423 { 1424 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1425 std::string ex(str, iter.base()); 1426 assert(ex == "+***********************0"); 1427 assert(ios.width() == 0); 1428 } 1429 } 1430 ios.imbue(lg); 1431 { 1432 ios.width(0); 1433 { 1434 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1435 std::string ex(str, iter.base()); 1436 assert(ex == "+0"); 1437 assert(ios.width() == 0); 1438 } 1439 ios.width(25); 1440 left(ios); 1441 { 1442 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1443 std::string ex(str, iter.base()); 1444 assert(ex == "+0***********************"); 1445 assert(ios.width() == 0); 1446 } 1447 ios.width(25); 1448 right(ios); 1449 { 1450 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1451 std::string ex(str, iter.base()); 1452 assert(ex == "***********************+0"); 1453 assert(ios.width() == 0); 1454 } 1455 ios.width(25); 1456 internal(ios); 1457 { 1458 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1459 std::string ex(str, iter.base()); 1460 assert(ex == "+***********************0"); 1461 assert(ios.width() == 0); 1462 } 1463 } 1464 } 1465 showpoint(ios); 1466 { 1467 ios.imbue(lc); 1468 { 1469 ios.width(0); 1470 { 1471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1472 std::string ex(str, iter.base()); 1473 assert(ex == "+0.00000"); 1474 assert(ios.width() == 0); 1475 } 1476 ios.width(25); 1477 left(ios); 1478 { 1479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1480 std::string ex(str, iter.base()); 1481 assert(ex == "+0.00000*****************"); 1482 assert(ios.width() == 0); 1483 } 1484 ios.width(25); 1485 right(ios); 1486 { 1487 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1488 std::string ex(str, iter.base()); 1489 assert(ex == "*****************+0.00000"); 1490 assert(ios.width() == 0); 1491 } 1492 ios.width(25); 1493 internal(ios); 1494 { 1495 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1496 std::string ex(str, iter.base()); 1497 assert(ex == "+*****************0.00000"); 1498 assert(ios.width() == 0); 1499 } 1500 } 1501 ios.imbue(lg); 1502 { 1503 ios.width(0); 1504 { 1505 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1506 std::string ex(str, iter.base()); 1507 assert(ex == "+0;00000"); 1508 assert(ios.width() == 0); 1509 } 1510 ios.width(25); 1511 left(ios); 1512 { 1513 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1514 std::string ex(str, iter.base()); 1515 assert(ex == "+0;00000*****************"); 1516 assert(ios.width() == 0); 1517 } 1518 ios.width(25); 1519 right(ios); 1520 { 1521 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1522 std::string ex(str, iter.base()); 1523 assert(ex == "*****************+0;00000"); 1524 assert(ios.width() == 0); 1525 } 1526 ios.width(25); 1527 internal(ios); 1528 { 1529 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1530 std::string ex(str, iter.base()); 1531 assert(ex == "+*****************0;00000"); 1532 assert(ios.width() == 0); 1533 } 1534 } 1535 } 1536 } 1537 } 1538 uppercase(ios); 1539 { 1540 noshowpos(ios); 1541 { 1542 noshowpoint(ios); 1543 { 1544 ios.imbue(lc); 1545 { 1546 ios.width(0); 1547 { 1548 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1549 std::string ex(str, iter.base()); 1550 assert(ex == "0"); 1551 assert(ios.width() == 0); 1552 } 1553 ios.width(25); 1554 left(ios); 1555 { 1556 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1557 std::string ex(str, iter.base()); 1558 assert(ex == "0************************"); 1559 assert(ios.width() == 0); 1560 } 1561 ios.width(25); 1562 right(ios); 1563 { 1564 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1565 std::string ex(str, iter.base()); 1566 assert(ex == "************************0"); 1567 assert(ios.width() == 0); 1568 } 1569 ios.width(25); 1570 internal(ios); 1571 { 1572 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1573 std::string ex(str, iter.base()); 1574 assert(ex == "************************0"); 1575 assert(ios.width() == 0); 1576 } 1577 } 1578 ios.imbue(lg); 1579 { 1580 ios.width(0); 1581 { 1582 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1583 std::string ex(str, iter.base()); 1584 assert(ex == "0"); 1585 assert(ios.width() == 0); 1586 } 1587 ios.width(25); 1588 left(ios); 1589 { 1590 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1591 std::string ex(str, iter.base()); 1592 assert(ex == "0************************"); 1593 assert(ios.width() == 0); 1594 } 1595 ios.width(25); 1596 right(ios); 1597 { 1598 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1599 std::string ex(str, iter.base()); 1600 assert(ex == "************************0"); 1601 assert(ios.width() == 0); 1602 } 1603 ios.width(25); 1604 internal(ios); 1605 { 1606 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1607 std::string ex(str, iter.base()); 1608 assert(ex == "************************0"); 1609 assert(ios.width() == 0); 1610 } 1611 } 1612 } 1613 showpoint(ios); 1614 { 1615 ios.imbue(lc); 1616 { 1617 ios.width(0); 1618 { 1619 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1620 std::string ex(str, iter.base()); 1621 assert(ex == "0.00000"); 1622 assert(ios.width() == 0); 1623 } 1624 ios.width(25); 1625 left(ios); 1626 { 1627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1628 std::string ex(str, iter.base()); 1629 assert(ex == "0.00000******************"); 1630 assert(ios.width() == 0); 1631 } 1632 ios.width(25); 1633 right(ios); 1634 { 1635 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1636 std::string ex(str, iter.base()); 1637 assert(ex == "******************0.00000"); 1638 assert(ios.width() == 0); 1639 } 1640 ios.width(25); 1641 internal(ios); 1642 { 1643 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1644 std::string ex(str, iter.base()); 1645 assert(ex == "******************0.00000"); 1646 assert(ios.width() == 0); 1647 } 1648 } 1649 ios.imbue(lg); 1650 { 1651 ios.width(0); 1652 { 1653 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1654 std::string ex(str, iter.base()); 1655 assert(ex == "0;00000"); 1656 assert(ios.width() == 0); 1657 } 1658 ios.width(25); 1659 left(ios); 1660 { 1661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1662 std::string ex(str, iter.base()); 1663 assert(ex == "0;00000******************"); 1664 assert(ios.width() == 0); 1665 } 1666 ios.width(25); 1667 right(ios); 1668 { 1669 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1670 std::string ex(str, iter.base()); 1671 assert(ex == "******************0;00000"); 1672 assert(ios.width() == 0); 1673 } 1674 ios.width(25); 1675 internal(ios); 1676 { 1677 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1678 std::string ex(str, iter.base()); 1679 assert(ex == "******************0;00000"); 1680 assert(ios.width() == 0); 1681 } 1682 } 1683 } 1684 } 1685 showpos(ios); 1686 { 1687 noshowpoint(ios); 1688 { 1689 ios.imbue(lc); 1690 { 1691 ios.width(0); 1692 { 1693 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1694 std::string ex(str, iter.base()); 1695 assert(ex == "+0"); 1696 assert(ios.width() == 0); 1697 } 1698 ios.width(25); 1699 left(ios); 1700 { 1701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1702 std::string ex(str, iter.base()); 1703 assert(ex == "+0***********************"); 1704 assert(ios.width() == 0); 1705 } 1706 ios.width(25); 1707 right(ios); 1708 { 1709 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1710 std::string ex(str, iter.base()); 1711 assert(ex == "***********************+0"); 1712 assert(ios.width() == 0); 1713 } 1714 ios.width(25); 1715 internal(ios); 1716 { 1717 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1718 std::string ex(str, iter.base()); 1719 assert(ex == "+***********************0"); 1720 assert(ios.width() == 0); 1721 } 1722 } 1723 ios.imbue(lg); 1724 { 1725 ios.width(0); 1726 { 1727 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1728 std::string ex(str, iter.base()); 1729 assert(ex == "+0"); 1730 assert(ios.width() == 0); 1731 } 1732 ios.width(25); 1733 left(ios); 1734 { 1735 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1736 std::string ex(str, iter.base()); 1737 assert(ex == "+0***********************"); 1738 assert(ios.width() == 0); 1739 } 1740 ios.width(25); 1741 right(ios); 1742 { 1743 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1744 std::string ex(str, iter.base()); 1745 assert(ex == "***********************+0"); 1746 assert(ios.width() == 0); 1747 } 1748 ios.width(25); 1749 internal(ios); 1750 { 1751 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1752 std::string ex(str, iter.base()); 1753 assert(ex == "+***********************0"); 1754 assert(ios.width() == 0); 1755 } 1756 } 1757 } 1758 showpoint(ios); 1759 { 1760 ios.imbue(lc); 1761 { 1762 ios.width(0); 1763 { 1764 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1765 std::string ex(str, iter.base()); 1766 assert(ex == "+0.00000"); 1767 assert(ios.width() == 0); 1768 } 1769 ios.width(25); 1770 left(ios); 1771 { 1772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1773 std::string ex(str, iter.base()); 1774 assert(ex == "+0.00000*****************"); 1775 assert(ios.width() == 0); 1776 } 1777 ios.width(25); 1778 right(ios); 1779 { 1780 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1781 std::string ex(str, iter.base()); 1782 assert(ex == "*****************+0.00000"); 1783 assert(ios.width() == 0); 1784 } 1785 ios.width(25); 1786 internal(ios); 1787 { 1788 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1789 std::string ex(str, iter.base()); 1790 assert(ex == "+*****************0.00000"); 1791 assert(ios.width() == 0); 1792 } 1793 } 1794 ios.imbue(lg); 1795 { 1796 ios.width(0); 1797 { 1798 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1799 std::string ex(str, iter.base()); 1800 assert(ex == "+0;00000"); 1801 assert(ios.width() == 0); 1802 } 1803 ios.width(25); 1804 left(ios); 1805 { 1806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1807 std::string ex(str, iter.base()); 1808 assert(ex == "+0;00000*****************"); 1809 assert(ios.width() == 0); 1810 } 1811 ios.width(25); 1812 right(ios); 1813 { 1814 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1815 std::string ex(str, iter.base()); 1816 assert(ex == "*****************+0;00000"); 1817 assert(ios.width() == 0); 1818 } 1819 ios.width(25); 1820 internal(ios); 1821 { 1822 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1823 std::string ex(str, iter.base()); 1824 assert(ex == "+*****************0;00000"); 1825 assert(ios.width() == 0); 1826 } 1827 } 1828 } 1829 } 1830 } 1831 } 1832 ios.precision(16); 1833 { 1834 nouppercase(ios); 1835 { 1836 noshowpos(ios); 1837 { 1838 noshowpoint(ios); 1839 { 1840 ios.imbue(lc); 1841 { 1842 ios.width(0); 1843 { 1844 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1845 std::string ex(str, iter.base()); 1846 assert(ex == "0"); 1847 assert(ios.width() == 0); 1848 } 1849 ios.width(25); 1850 left(ios); 1851 { 1852 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1853 std::string ex(str, iter.base()); 1854 assert(ex == "0************************"); 1855 assert(ios.width() == 0); 1856 } 1857 ios.width(25); 1858 right(ios); 1859 { 1860 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1861 std::string ex(str, iter.base()); 1862 assert(ex == "************************0"); 1863 assert(ios.width() == 0); 1864 } 1865 ios.width(25); 1866 internal(ios); 1867 { 1868 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1869 std::string ex(str, iter.base()); 1870 assert(ex == "************************0"); 1871 assert(ios.width() == 0); 1872 } 1873 } 1874 ios.imbue(lg); 1875 { 1876 ios.width(0); 1877 { 1878 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1879 std::string ex(str, iter.base()); 1880 assert(ex == "0"); 1881 assert(ios.width() == 0); 1882 } 1883 ios.width(25); 1884 left(ios); 1885 { 1886 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1887 std::string ex(str, iter.base()); 1888 assert(ex == "0************************"); 1889 assert(ios.width() == 0); 1890 } 1891 ios.width(25); 1892 right(ios); 1893 { 1894 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1895 std::string ex(str, iter.base()); 1896 assert(ex == "************************0"); 1897 assert(ios.width() == 0); 1898 } 1899 ios.width(25); 1900 internal(ios); 1901 { 1902 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1903 std::string ex(str, iter.base()); 1904 assert(ex == "************************0"); 1905 assert(ios.width() == 0); 1906 } 1907 } 1908 } 1909 showpoint(ios); 1910 { 1911 ios.imbue(lc); 1912 { 1913 ios.width(0); 1914 { 1915 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1916 std::string ex(str, iter.base()); 1917 assert(ex == "0.000000000000000"); 1918 assert(ios.width() == 0); 1919 } 1920 ios.width(25); 1921 left(ios); 1922 { 1923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1924 std::string ex(str, iter.base()); 1925 assert(ex == "0.000000000000000********"); 1926 assert(ios.width() == 0); 1927 } 1928 ios.width(25); 1929 right(ios); 1930 { 1931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1932 std::string ex(str, iter.base()); 1933 assert(ex == "********0.000000000000000"); 1934 assert(ios.width() == 0); 1935 } 1936 ios.width(25); 1937 internal(ios); 1938 { 1939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1940 std::string ex(str, iter.base()); 1941 assert(ex == "********0.000000000000000"); 1942 assert(ios.width() == 0); 1943 } 1944 } 1945 ios.imbue(lg); 1946 { 1947 ios.width(0); 1948 { 1949 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1950 std::string ex(str, iter.base()); 1951 assert(ex == "0;000000000000000"); 1952 assert(ios.width() == 0); 1953 } 1954 ios.width(25); 1955 left(ios); 1956 { 1957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1958 std::string ex(str, iter.base()); 1959 assert(ex == "0;000000000000000********"); 1960 assert(ios.width() == 0); 1961 } 1962 ios.width(25); 1963 right(ios); 1964 { 1965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1966 std::string ex(str, iter.base()); 1967 assert(ex == "********0;000000000000000"); 1968 assert(ios.width() == 0); 1969 } 1970 ios.width(25); 1971 internal(ios); 1972 { 1973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1974 std::string ex(str, iter.base()); 1975 assert(ex == "********0;000000000000000"); 1976 assert(ios.width() == 0); 1977 } 1978 } 1979 } 1980 } 1981 showpos(ios); 1982 { 1983 noshowpoint(ios); 1984 { 1985 ios.imbue(lc); 1986 { 1987 ios.width(0); 1988 { 1989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1990 std::string ex(str, iter.base()); 1991 assert(ex == "+0"); 1992 assert(ios.width() == 0); 1993 } 1994 ios.width(25); 1995 left(ios); 1996 { 1997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1998 std::string ex(str, iter.base()); 1999 assert(ex == "+0***********************"); 2000 assert(ios.width() == 0); 2001 } 2002 ios.width(25); 2003 right(ios); 2004 { 2005 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2006 std::string ex(str, iter.base()); 2007 assert(ex == "***********************+0"); 2008 assert(ios.width() == 0); 2009 } 2010 ios.width(25); 2011 internal(ios); 2012 { 2013 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2014 std::string ex(str, iter.base()); 2015 assert(ex == "+***********************0"); 2016 assert(ios.width() == 0); 2017 } 2018 } 2019 ios.imbue(lg); 2020 { 2021 ios.width(0); 2022 { 2023 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2024 std::string ex(str, iter.base()); 2025 assert(ex == "+0"); 2026 assert(ios.width() == 0); 2027 } 2028 ios.width(25); 2029 left(ios); 2030 { 2031 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2032 std::string ex(str, iter.base()); 2033 assert(ex == "+0***********************"); 2034 assert(ios.width() == 0); 2035 } 2036 ios.width(25); 2037 right(ios); 2038 { 2039 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2040 std::string ex(str, iter.base()); 2041 assert(ex == "***********************+0"); 2042 assert(ios.width() == 0); 2043 } 2044 ios.width(25); 2045 internal(ios); 2046 { 2047 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2048 std::string ex(str, iter.base()); 2049 assert(ex == "+***********************0"); 2050 assert(ios.width() == 0); 2051 } 2052 } 2053 } 2054 showpoint(ios); 2055 { 2056 ios.imbue(lc); 2057 { 2058 ios.width(0); 2059 { 2060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2061 std::string ex(str, iter.base()); 2062 assert(ex == "+0.000000000000000"); 2063 assert(ios.width() == 0); 2064 } 2065 ios.width(25); 2066 left(ios); 2067 { 2068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2069 std::string ex(str, iter.base()); 2070 assert(ex == "+0.000000000000000*******"); 2071 assert(ios.width() == 0); 2072 } 2073 ios.width(25); 2074 right(ios); 2075 { 2076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2077 std::string ex(str, iter.base()); 2078 assert(ex == "*******+0.000000000000000"); 2079 assert(ios.width() == 0); 2080 } 2081 ios.width(25); 2082 internal(ios); 2083 { 2084 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2085 std::string ex(str, iter.base()); 2086 assert(ex == "+*******0.000000000000000"); 2087 assert(ios.width() == 0); 2088 } 2089 } 2090 ios.imbue(lg); 2091 { 2092 ios.width(0); 2093 { 2094 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2095 std::string ex(str, iter.base()); 2096 assert(ex == "+0;000000000000000"); 2097 assert(ios.width() == 0); 2098 } 2099 ios.width(25); 2100 left(ios); 2101 { 2102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2103 std::string ex(str, iter.base()); 2104 assert(ex == "+0;000000000000000*******"); 2105 assert(ios.width() == 0); 2106 } 2107 ios.width(25); 2108 right(ios); 2109 { 2110 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2111 std::string ex(str, iter.base()); 2112 assert(ex == "*******+0;000000000000000"); 2113 assert(ios.width() == 0); 2114 } 2115 ios.width(25); 2116 internal(ios); 2117 { 2118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2119 std::string ex(str, iter.base()); 2120 assert(ex == "+*******0;000000000000000"); 2121 assert(ios.width() == 0); 2122 } 2123 } 2124 } 2125 } 2126 } 2127 uppercase(ios); 2128 { 2129 noshowpos(ios); 2130 { 2131 noshowpoint(ios); 2132 { 2133 ios.imbue(lc); 2134 { 2135 ios.width(0); 2136 { 2137 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2138 std::string ex(str, iter.base()); 2139 assert(ex == "0"); 2140 assert(ios.width() == 0); 2141 } 2142 ios.width(25); 2143 left(ios); 2144 { 2145 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2146 std::string ex(str, iter.base()); 2147 assert(ex == "0************************"); 2148 assert(ios.width() == 0); 2149 } 2150 ios.width(25); 2151 right(ios); 2152 { 2153 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2154 std::string ex(str, iter.base()); 2155 assert(ex == "************************0"); 2156 assert(ios.width() == 0); 2157 } 2158 ios.width(25); 2159 internal(ios); 2160 { 2161 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2162 std::string ex(str, iter.base()); 2163 assert(ex == "************************0"); 2164 assert(ios.width() == 0); 2165 } 2166 } 2167 ios.imbue(lg); 2168 { 2169 ios.width(0); 2170 { 2171 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2172 std::string ex(str, iter.base()); 2173 assert(ex == "0"); 2174 assert(ios.width() == 0); 2175 } 2176 ios.width(25); 2177 left(ios); 2178 { 2179 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2180 std::string ex(str, iter.base()); 2181 assert(ex == "0************************"); 2182 assert(ios.width() == 0); 2183 } 2184 ios.width(25); 2185 right(ios); 2186 { 2187 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2188 std::string ex(str, iter.base()); 2189 assert(ex == "************************0"); 2190 assert(ios.width() == 0); 2191 } 2192 ios.width(25); 2193 internal(ios); 2194 { 2195 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2196 std::string ex(str, iter.base()); 2197 assert(ex == "************************0"); 2198 assert(ios.width() == 0); 2199 } 2200 } 2201 } 2202 showpoint(ios); 2203 { 2204 ios.imbue(lc); 2205 { 2206 ios.width(0); 2207 { 2208 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2209 std::string ex(str, iter.base()); 2210 assert(ex == "0.000000000000000"); 2211 assert(ios.width() == 0); 2212 } 2213 ios.width(25); 2214 left(ios); 2215 { 2216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2217 std::string ex(str, iter.base()); 2218 assert(ex == "0.000000000000000********"); 2219 assert(ios.width() == 0); 2220 } 2221 ios.width(25); 2222 right(ios); 2223 { 2224 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2225 std::string ex(str, iter.base()); 2226 assert(ex == "********0.000000000000000"); 2227 assert(ios.width() == 0); 2228 } 2229 ios.width(25); 2230 internal(ios); 2231 { 2232 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2233 std::string ex(str, iter.base()); 2234 assert(ex == "********0.000000000000000"); 2235 assert(ios.width() == 0); 2236 } 2237 } 2238 ios.imbue(lg); 2239 { 2240 ios.width(0); 2241 { 2242 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2243 std::string ex(str, iter.base()); 2244 assert(ex == "0;000000000000000"); 2245 assert(ios.width() == 0); 2246 } 2247 ios.width(25); 2248 left(ios); 2249 { 2250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2251 std::string ex(str, iter.base()); 2252 assert(ex == "0;000000000000000********"); 2253 assert(ios.width() == 0); 2254 } 2255 ios.width(25); 2256 right(ios); 2257 { 2258 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2259 std::string ex(str, iter.base()); 2260 assert(ex == "********0;000000000000000"); 2261 assert(ios.width() == 0); 2262 } 2263 ios.width(25); 2264 internal(ios); 2265 { 2266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2267 std::string ex(str, iter.base()); 2268 assert(ex == "********0;000000000000000"); 2269 assert(ios.width() == 0); 2270 } 2271 } 2272 } 2273 } 2274 showpos(ios); 2275 { 2276 noshowpoint(ios); 2277 { 2278 ios.imbue(lc); 2279 { 2280 ios.width(0); 2281 { 2282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2283 std::string ex(str, iter.base()); 2284 assert(ex == "+0"); 2285 assert(ios.width() == 0); 2286 } 2287 ios.width(25); 2288 left(ios); 2289 { 2290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2291 std::string ex(str, iter.base()); 2292 assert(ex == "+0***********************"); 2293 assert(ios.width() == 0); 2294 } 2295 ios.width(25); 2296 right(ios); 2297 { 2298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2299 std::string ex(str, iter.base()); 2300 assert(ex == "***********************+0"); 2301 assert(ios.width() == 0); 2302 } 2303 ios.width(25); 2304 internal(ios); 2305 { 2306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2307 std::string ex(str, iter.base()); 2308 assert(ex == "+***********************0"); 2309 assert(ios.width() == 0); 2310 } 2311 } 2312 ios.imbue(lg); 2313 { 2314 ios.width(0); 2315 { 2316 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2317 std::string ex(str, iter.base()); 2318 assert(ex == "+0"); 2319 assert(ios.width() == 0); 2320 } 2321 ios.width(25); 2322 left(ios); 2323 { 2324 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2325 std::string ex(str, iter.base()); 2326 assert(ex == "+0***********************"); 2327 assert(ios.width() == 0); 2328 } 2329 ios.width(25); 2330 right(ios); 2331 { 2332 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2333 std::string ex(str, iter.base()); 2334 assert(ex == "***********************+0"); 2335 assert(ios.width() == 0); 2336 } 2337 ios.width(25); 2338 internal(ios); 2339 { 2340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2341 std::string ex(str, iter.base()); 2342 assert(ex == "+***********************0"); 2343 assert(ios.width() == 0); 2344 } 2345 } 2346 } 2347 showpoint(ios); 2348 { 2349 ios.imbue(lc); 2350 { 2351 ios.width(0); 2352 { 2353 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2354 std::string ex(str, iter.base()); 2355 assert(ex == "+0.000000000000000"); 2356 assert(ios.width() == 0); 2357 } 2358 ios.width(25); 2359 left(ios); 2360 { 2361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2362 std::string ex(str, iter.base()); 2363 assert(ex == "+0.000000000000000*******"); 2364 assert(ios.width() == 0); 2365 } 2366 ios.width(25); 2367 right(ios); 2368 { 2369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2370 std::string ex(str, iter.base()); 2371 assert(ex == "*******+0.000000000000000"); 2372 assert(ios.width() == 0); 2373 } 2374 ios.width(25); 2375 internal(ios); 2376 { 2377 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2378 std::string ex(str, iter.base()); 2379 assert(ex == "+*******0.000000000000000"); 2380 assert(ios.width() == 0); 2381 } 2382 } 2383 ios.imbue(lg); 2384 { 2385 ios.width(0); 2386 { 2387 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2388 std::string ex(str, iter.base()); 2389 assert(ex == "+0;000000000000000"); 2390 assert(ios.width() == 0); 2391 } 2392 ios.width(25); 2393 left(ios); 2394 { 2395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2396 std::string ex(str, iter.base()); 2397 assert(ex == "+0;000000000000000*******"); 2398 assert(ios.width() == 0); 2399 } 2400 ios.width(25); 2401 right(ios); 2402 { 2403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2404 std::string ex(str, iter.base()); 2405 assert(ex == "*******+0;000000000000000"); 2406 assert(ios.width() == 0); 2407 } 2408 ios.width(25); 2409 internal(ios); 2410 { 2411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2412 std::string ex(str, iter.base()); 2413 assert(ex == "+*******0;000000000000000"); 2414 assert(ios.width() == 0); 2415 } 2416 } 2417 } 2418 } 2419 } 2420 } 2421 ios.precision(60); 2422 { 2423 nouppercase(ios); 2424 { 2425 noshowpos(ios); 2426 { 2427 noshowpoint(ios); 2428 { 2429 ios.imbue(lc); 2430 { 2431 ios.width(0); 2432 { 2433 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2434 std::string ex(str, iter.base()); 2435 assert(ex == "0"); 2436 assert(ios.width() == 0); 2437 } 2438 ios.width(25); 2439 left(ios); 2440 { 2441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2442 std::string ex(str, iter.base()); 2443 assert(ex == "0************************"); 2444 assert(ios.width() == 0); 2445 } 2446 ios.width(25); 2447 right(ios); 2448 { 2449 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2450 std::string ex(str, iter.base()); 2451 assert(ex == "************************0"); 2452 assert(ios.width() == 0); 2453 } 2454 ios.width(25); 2455 internal(ios); 2456 { 2457 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2458 std::string ex(str, iter.base()); 2459 assert(ex == "************************0"); 2460 assert(ios.width() == 0); 2461 } 2462 } 2463 ios.imbue(lg); 2464 { 2465 ios.width(0); 2466 { 2467 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2468 std::string ex(str, iter.base()); 2469 assert(ex == "0"); 2470 assert(ios.width() == 0); 2471 } 2472 ios.width(25); 2473 left(ios); 2474 { 2475 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2476 std::string ex(str, iter.base()); 2477 assert(ex == "0************************"); 2478 assert(ios.width() == 0); 2479 } 2480 ios.width(25); 2481 right(ios); 2482 { 2483 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2484 std::string ex(str, iter.base()); 2485 assert(ex == "************************0"); 2486 assert(ios.width() == 0); 2487 } 2488 ios.width(25); 2489 internal(ios); 2490 { 2491 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2492 std::string ex(str, iter.base()); 2493 assert(ex == "************************0"); 2494 assert(ios.width() == 0); 2495 } 2496 } 2497 } 2498 showpoint(ios); 2499 { 2500 ios.imbue(lc); 2501 { 2502 ios.width(0); 2503 { 2504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2505 std::string ex(str, iter.base()); 2506 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2507 assert(ios.width() == 0); 2508 } 2509 ios.width(25); 2510 left(ios); 2511 { 2512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2513 std::string ex(str, iter.base()); 2514 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2515 assert(ios.width() == 0); 2516 } 2517 ios.width(25); 2518 right(ios); 2519 { 2520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2521 std::string ex(str, iter.base()); 2522 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2523 assert(ios.width() == 0); 2524 } 2525 ios.width(25); 2526 internal(ios); 2527 { 2528 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2529 std::string ex(str, iter.base()); 2530 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2531 assert(ios.width() == 0); 2532 } 2533 } 2534 ios.imbue(lg); 2535 { 2536 ios.width(0); 2537 { 2538 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2539 std::string ex(str, iter.base()); 2540 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2541 assert(ios.width() == 0); 2542 } 2543 ios.width(25); 2544 left(ios); 2545 { 2546 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2547 std::string ex(str, iter.base()); 2548 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2549 assert(ios.width() == 0); 2550 } 2551 ios.width(25); 2552 right(ios); 2553 { 2554 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2555 std::string ex(str, iter.base()); 2556 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2557 assert(ios.width() == 0); 2558 } 2559 ios.width(25); 2560 internal(ios); 2561 { 2562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2563 std::string ex(str, iter.base()); 2564 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2565 assert(ios.width() == 0); 2566 } 2567 } 2568 } 2569 } 2570 showpos(ios); 2571 { 2572 noshowpoint(ios); 2573 { 2574 ios.imbue(lc); 2575 { 2576 ios.width(0); 2577 { 2578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2579 std::string ex(str, iter.base()); 2580 assert(ex == "+0"); 2581 assert(ios.width() == 0); 2582 } 2583 ios.width(25); 2584 left(ios); 2585 { 2586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2587 std::string ex(str, iter.base()); 2588 assert(ex == "+0***********************"); 2589 assert(ios.width() == 0); 2590 } 2591 ios.width(25); 2592 right(ios); 2593 { 2594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2595 std::string ex(str, iter.base()); 2596 assert(ex == "***********************+0"); 2597 assert(ios.width() == 0); 2598 } 2599 ios.width(25); 2600 internal(ios); 2601 { 2602 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2603 std::string ex(str, iter.base()); 2604 assert(ex == "+***********************0"); 2605 assert(ios.width() == 0); 2606 } 2607 } 2608 ios.imbue(lg); 2609 { 2610 ios.width(0); 2611 { 2612 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2613 std::string ex(str, iter.base()); 2614 assert(ex == "+0"); 2615 assert(ios.width() == 0); 2616 } 2617 ios.width(25); 2618 left(ios); 2619 { 2620 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2621 std::string ex(str, iter.base()); 2622 assert(ex == "+0***********************"); 2623 assert(ios.width() == 0); 2624 } 2625 ios.width(25); 2626 right(ios); 2627 { 2628 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2629 std::string ex(str, iter.base()); 2630 assert(ex == "***********************+0"); 2631 assert(ios.width() == 0); 2632 } 2633 ios.width(25); 2634 internal(ios); 2635 { 2636 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2637 std::string ex(str, iter.base()); 2638 assert(ex == "+***********************0"); 2639 assert(ios.width() == 0); 2640 } 2641 } 2642 } 2643 showpoint(ios); 2644 { 2645 ios.imbue(lc); 2646 { 2647 ios.width(0); 2648 { 2649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2650 std::string ex(str, iter.base()); 2651 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2652 assert(ios.width() == 0); 2653 } 2654 ios.width(25); 2655 left(ios); 2656 { 2657 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2658 std::string ex(str, iter.base()); 2659 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2660 assert(ios.width() == 0); 2661 } 2662 ios.width(25); 2663 right(ios); 2664 { 2665 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2666 std::string ex(str, iter.base()); 2667 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2668 assert(ios.width() == 0); 2669 } 2670 ios.width(25); 2671 internal(ios); 2672 { 2673 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2674 std::string ex(str, iter.base()); 2675 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2676 assert(ios.width() == 0); 2677 } 2678 } 2679 ios.imbue(lg); 2680 { 2681 ios.width(0); 2682 { 2683 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2684 std::string ex(str, iter.base()); 2685 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2686 assert(ios.width() == 0); 2687 } 2688 ios.width(25); 2689 left(ios); 2690 { 2691 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2692 std::string ex(str, iter.base()); 2693 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2694 assert(ios.width() == 0); 2695 } 2696 ios.width(25); 2697 right(ios); 2698 { 2699 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2700 std::string ex(str, iter.base()); 2701 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2702 assert(ios.width() == 0); 2703 } 2704 ios.width(25); 2705 internal(ios); 2706 { 2707 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2708 std::string ex(str, iter.base()); 2709 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2710 assert(ios.width() == 0); 2711 } 2712 } 2713 } 2714 } 2715 } 2716 uppercase(ios); 2717 { 2718 noshowpos(ios); 2719 { 2720 noshowpoint(ios); 2721 { 2722 ios.imbue(lc); 2723 { 2724 ios.width(0); 2725 { 2726 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2727 std::string ex(str, iter.base()); 2728 assert(ex == "0"); 2729 assert(ios.width() == 0); 2730 } 2731 ios.width(25); 2732 left(ios); 2733 { 2734 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2735 std::string ex(str, iter.base()); 2736 assert(ex == "0************************"); 2737 assert(ios.width() == 0); 2738 } 2739 ios.width(25); 2740 right(ios); 2741 { 2742 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2743 std::string ex(str, iter.base()); 2744 assert(ex == "************************0"); 2745 assert(ios.width() == 0); 2746 } 2747 ios.width(25); 2748 internal(ios); 2749 { 2750 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2751 std::string ex(str, iter.base()); 2752 assert(ex == "************************0"); 2753 assert(ios.width() == 0); 2754 } 2755 } 2756 ios.imbue(lg); 2757 { 2758 ios.width(0); 2759 { 2760 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2761 std::string ex(str, iter.base()); 2762 assert(ex == "0"); 2763 assert(ios.width() == 0); 2764 } 2765 ios.width(25); 2766 left(ios); 2767 { 2768 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2769 std::string ex(str, iter.base()); 2770 assert(ex == "0************************"); 2771 assert(ios.width() == 0); 2772 } 2773 ios.width(25); 2774 right(ios); 2775 { 2776 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2777 std::string ex(str, iter.base()); 2778 assert(ex == "************************0"); 2779 assert(ios.width() == 0); 2780 } 2781 ios.width(25); 2782 internal(ios); 2783 { 2784 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2785 std::string ex(str, iter.base()); 2786 assert(ex == "************************0"); 2787 assert(ios.width() == 0); 2788 } 2789 } 2790 } 2791 showpoint(ios); 2792 { 2793 ios.imbue(lc); 2794 { 2795 ios.width(0); 2796 { 2797 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2798 std::string ex(str, iter.base()); 2799 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2800 assert(ios.width() == 0); 2801 } 2802 ios.width(25); 2803 left(ios); 2804 { 2805 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2806 std::string ex(str, iter.base()); 2807 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2808 assert(ios.width() == 0); 2809 } 2810 ios.width(25); 2811 right(ios); 2812 { 2813 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2814 std::string ex(str, iter.base()); 2815 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2816 assert(ios.width() == 0); 2817 } 2818 ios.width(25); 2819 internal(ios); 2820 { 2821 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2822 std::string ex(str, iter.base()); 2823 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2824 assert(ios.width() == 0); 2825 } 2826 } 2827 ios.imbue(lg); 2828 { 2829 ios.width(0); 2830 { 2831 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2832 std::string ex(str, iter.base()); 2833 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2834 assert(ios.width() == 0); 2835 } 2836 ios.width(25); 2837 left(ios); 2838 { 2839 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2840 std::string ex(str, iter.base()); 2841 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2842 assert(ios.width() == 0); 2843 } 2844 ios.width(25); 2845 right(ios); 2846 { 2847 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2848 std::string ex(str, iter.base()); 2849 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2850 assert(ios.width() == 0); 2851 } 2852 ios.width(25); 2853 internal(ios); 2854 { 2855 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2856 std::string ex(str, iter.base()); 2857 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2858 assert(ios.width() == 0); 2859 } 2860 } 2861 } 2862 } 2863 showpos(ios); 2864 { 2865 noshowpoint(ios); 2866 { 2867 ios.imbue(lc); 2868 { 2869 ios.width(0); 2870 { 2871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2872 std::string ex(str, iter.base()); 2873 assert(ex == "+0"); 2874 assert(ios.width() == 0); 2875 } 2876 ios.width(25); 2877 left(ios); 2878 { 2879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2880 std::string ex(str, iter.base()); 2881 assert(ex == "+0***********************"); 2882 assert(ios.width() == 0); 2883 } 2884 ios.width(25); 2885 right(ios); 2886 { 2887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2888 std::string ex(str, iter.base()); 2889 assert(ex == "***********************+0"); 2890 assert(ios.width() == 0); 2891 } 2892 ios.width(25); 2893 internal(ios); 2894 { 2895 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2896 std::string ex(str, iter.base()); 2897 assert(ex == "+***********************0"); 2898 assert(ios.width() == 0); 2899 } 2900 } 2901 ios.imbue(lg); 2902 { 2903 ios.width(0); 2904 { 2905 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2906 std::string ex(str, iter.base()); 2907 assert(ex == "+0"); 2908 assert(ios.width() == 0); 2909 } 2910 ios.width(25); 2911 left(ios); 2912 { 2913 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2914 std::string ex(str, iter.base()); 2915 assert(ex == "+0***********************"); 2916 assert(ios.width() == 0); 2917 } 2918 ios.width(25); 2919 right(ios); 2920 { 2921 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2922 std::string ex(str, iter.base()); 2923 assert(ex == "***********************+0"); 2924 assert(ios.width() == 0); 2925 } 2926 ios.width(25); 2927 internal(ios); 2928 { 2929 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2930 std::string ex(str, iter.base()); 2931 assert(ex == "+***********************0"); 2932 assert(ios.width() == 0); 2933 } 2934 } 2935 } 2936 showpoint(ios); 2937 { 2938 ios.imbue(lc); 2939 { 2940 ios.width(0); 2941 { 2942 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2943 std::string ex(str, iter.base()); 2944 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2945 assert(ios.width() == 0); 2946 } 2947 ios.width(25); 2948 left(ios); 2949 { 2950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2951 std::string ex(str, iter.base()); 2952 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2953 assert(ios.width() == 0); 2954 } 2955 ios.width(25); 2956 right(ios); 2957 { 2958 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2959 std::string ex(str, iter.base()); 2960 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2961 assert(ios.width() == 0); 2962 } 2963 ios.width(25); 2964 internal(ios); 2965 { 2966 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2967 std::string ex(str, iter.base()); 2968 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2969 assert(ios.width() == 0); 2970 } 2971 } 2972 ios.imbue(lg); 2973 { 2974 ios.width(0); 2975 { 2976 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2977 std::string ex(str, iter.base()); 2978 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2979 assert(ios.width() == 0); 2980 } 2981 ios.width(25); 2982 left(ios); 2983 { 2984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2985 std::string ex(str, iter.base()); 2986 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2987 assert(ios.width() == 0); 2988 } 2989 ios.width(25); 2990 right(ios); 2991 { 2992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2993 std::string ex(str, iter.base()); 2994 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2995 assert(ios.width() == 0); 2996 } 2997 ios.width(25); 2998 internal(ios); 2999 { 3000 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3001 std::string ex(str, iter.base()); 3002 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 3003 assert(ios.width() == 0); 3004 } 3005 } 3006 } 3007 } 3008 } 3009 } 3010 } 3011 } 3012 } 3013 3014 void test2() 3015 { 3016 char str[200]; 3017 output_iterator<char*> iter; 3018 std::locale lc = std::locale::classic(); 3019 std::locale lg(lc, new my_numpunct); 3020 const my_facet f(1); 3021 { 3022 long double v = -0.; 3023 std::ios ios(0); 3024 // %g 3025 { 3026 ios.precision(0); 3027 { 3028 nouppercase(ios); 3029 { 3030 noshowpos(ios); 3031 { 3032 noshowpoint(ios); 3033 { 3034 ios.imbue(lc); 3035 { 3036 ios.width(0); 3037 { 3038 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3039 std::string ex(str, iter.base()); 3040 assert(ex == "-0"); 3041 assert(ios.width() == 0); 3042 } 3043 ios.width(25); 3044 left(ios); 3045 { 3046 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3047 std::string ex(str, iter.base()); 3048 assert(ex == "-0***********************"); 3049 assert(ios.width() == 0); 3050 } 3051 ios.width(25); 3052 right(ios); 3053 { 3054 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3055 std::string ex(str, iter.base()); 3056 assert(ex == "***********************-0"); 3057 assert(ios.width() == 0); 3058 } 3059 ios.width(25); 3060 internal(ios); 3061 { 3062 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3063 std::string ex(str, iter.base()); 3064 assert(ex == "-***********************0"); 3065 assert(ios.width() == 0); 3066 } 3067 } 3068 ios.imbue(lg); 3069 { 3070 ios.width(0); 3071 { 3072 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3073 std::string ex(str, iter.base()); 3074 assert(ex == "-0"); 3075 assert(ios.width() == 0); 3076 } 3077 ios.width(25); 3078 left(ios); 3079 { 3080 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3081 std::string ex(str, iter.base()); 3082 assert(ex == "-0***********************"); 3083 assert(ios.width() == 0); 3084 } 3085 ios.width(25); 3086 right(ios); 3087 { 3088 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3089 std::string ex(str, iter.base()); 3090 assert(ex == "***********************-0"); 3091 assert(ios.width() == 0); 3092 } 3093 ios.width(25); 3094 internal(ios); 3095 { 3096 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3097 std::string ex(str, iter.base()); 3098 assert(ex == "-***********************0"); 3099 assert(ios.width() == 0); 3100 } 3101 } 3102 } 3103 showpoint(ios); 3104 { 3105 ios.imbue(lc); 3106 { 3107 ios.width(0); 3108 { 3109 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3110 std::string ex(str, iter.base()); 3111 assert(ex == "-0."); 3112 assert(ios.width() == 0); 3113 } 3114 ios.width(25); 3115 left(ios); 3116 { 3117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3118 std::string ex(str, iter.base()); 3119 assert(ex == "-0.**********************"); 3120 assert(ios.width() == 0); 3121 } 3122 ios.width(25); 3123 right(ios); 3124 { 3125 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3126 std::string ex(str, iter.base()); 3127 assert(ex == "**********************-0."); 3128 assert(ios.width() == 0); 3129 } 3130 ios.width(25); 3131 internal(ios); 3132 { 3133 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3134 std::string ex(str, iter.base()); 3135 assert(ex == "-**********************0."); 3136 assert(ios.width() == 0); 3137 } 3138 } 3139 ios.imbue(lg); 3140 { 3141 ios.width(0); 3142 { 3143 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3144 std::string ex(str, iter.base()); 3145 assert(ex == "-0;"); 3146 assert(ios.width() == 0); 3147 } 3148 ios.width(25); 3149 left(ios); 3150 { 3151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3152 std::string ex(str, iter.base()); 3153 assert(ex == "-0;**********************"); 3154 assert(ios.width() == 0); 3155 } 3156 ios.width(25); 3157 right(ios); 3158 { 3159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3160 std::string ex(str, iter.base()); 3161 assert(ex == "**********************-0;"); 3162 assert(ios.width() == 0); 3163 } 3164 ios.width(25); 3165 internal(ios); 3166 { 3167 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3168 std::string ex(str, iter.base()); 3169 assert(ex == "-**********************0;"); 3170 assert(ios.width() == 0); 3171 } 3172 } 3173 } 3174 } 3175 showpos(ios); 3176 { 3177 noshowpoint(ios); 3178 { 3179 ios.imbue(lc); 3180 { 3181 ios.width(0); 3182 { 3183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3184 std::string ex(str, iter.base()); 3185 assert(ex == "-0"); 3186 assert(ios.width() == 0); 3187 } 3188 ios.width(25); 3189 left(ios); 3190 { 3191 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3192 std::string ex(str, iter.base()); 3193 assert(ex == "-0***********************"); 3194 assert(ios.width() == 0); 3195 } 3196 ios.width(25); 3197 right(ios); 3198 { 3199 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3200 std::string ex(str, iter.base()); 3201 assert(ex == "***********************-0"); 3202 assert(ios.width() == 0); 3203 } 3204 ios.width(25); 3205 internal(ios); 3206 { 3207 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3208 std::string ex(str, iter.base()); 3209 assert(ex == "-***********************0"); 3210 assert(ios.width() == 0); 3211 } 3212 } 3213 ios.imbue(lg); 3214 { 3215 ios.width(0); 3216 { 3217 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3218 std::string ex(str, iter.base()); 3219 assert(ex == "-0"); 3220 assert(ios.width() == 0); 3221 } 3222 ios.width(25); 3223 left(ios); 3224 { 3225 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3226 std::string ex(str, iter.base()); 3227 assert(ex == "-0***********************"); 3228 assert(ios.width() == 0); 3229 } 3230 ios.width(25); 3231 right(ios); 3232 { 3233 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3234 std::string ex(str, iter.base()); 3235 assert(ex == "***********************-0"); 3236 assert(ios.width() == 0); 3237 } 3238 ios.width(25); 3239 internal(ios); 3240 { 3241 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3242 std::string ex(str, iter.base()); 3243 assert(ex == "-***********************0"); 3244 assert(ios.width() == 0); 3245 } 3246 } 3247 } 3248 showpoint(ios); 3249 { 3250 ios.imbue(lc); 3251 { 3252 ios.width(0); 3253 { 3254 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3255 std::string ex(str, iter.base()); 3256 assert(ex == "-0."); 3257 assert(ios.width() == 0); 3258 } 3259 ios.width(25); 3260 left(ios); 3261 { 3262 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3263 std::string ex(str, iter.base()); 3264 assert(ex == "-0.**********************"); 3265 assert(ios.width() == 0); 3266 } 3267 ios.width(25); 3268 right(ios); 3269 { 3270 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3271 std::string ex(str, iter.base()); 3272 assert(ex == "**********************-0."); 3273 assert(ios.width() == 0); 3274 } 3275 ios.width(25); 3276 internal(ios); 3277 { 3278 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3279 std::string ex(str, iter.base()); 3280 assert(ex == "-**********************0."); 3281 assert(ios.width() == 0); 3282 } 3283 } 3284 ios.imbue(lg); 3285 { 3286 ios.width(0); 3287 { 3288 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3289 std::string ex(str, iter.base()); 3290 assert(ex == "-0;"); 3291 assert(ios.width() == 0); 3292 } 3293 ios.width(25); 3294 left(ios); 3295 { 3296 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3297 std::string ex(str, iter.base()); 3298 assert(ex == "-0;**********************"); 3299 assert(ios.width() == 0); 3300 } 3301 ios.width(25); 3302 right(ios); 3303 { 3304 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3305 std::string ex(str, iter.base()); 3306 assert(ex == "**********************-0;"); 3307 assert(ios.width() == 0); 3308 } 3309 ios.width(25); 3310 internal(ios); 3311 { 3312 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3313 std::string ex(str, iter.base()); 3314 assert(ex == "-**********************0;"); 3315 assert(ios.width() == 0); 3316 } 3317 } 3318 } 3319 } 3320 } 3321 uppercase(ios); 3322 { 3323 noshowpos(ios); 3324 { 3325 noshowpoint(ios); 3326 { 3327 ios.imbue(lc); 3328 { 3329 ios.width(0); 3330 { 3331 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3332 std::string ex(str, iter.base()); 3333 assert(ex == "-0"); 3334 assert(ios.width() == 0); 3335 } 3336 ios.width(25); 3337 left(ios); 3338 { 3339 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3340 std::string ex(str, iter.base()); 3341 assert(ex == "-0***********************"); 3342 assert(ios.width() == 0); 3343 } 3344 ios.width(25); 3345 right(ios); 3346 { 3347 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3348 std::string ex(str, iter.base()); 3349 assert(ex == "***********************-0"); 3350 assert(ios.width() == 0); 3351 } 3352 ios.width(25); 3353 internal(ios); 3354 { 3355 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3356 std::string ex(str, iter.base()); 3357 assert(ex == "-***********************0"); 3358 assert(ios.width() == 0); 3359 } 3360 } 3361 ios.imbue(lg); 3362 { 3363 ios.width(0); 3364 { 3365 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3366 std::string ex(str, iter.base()); 3367 assert(ex == "-0"); 3368 assert(ios.width() == 0); 3369 } 3370 ios.width(25); 3371 left(ios); 3372 { 3373 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3374 std::string ex(str, iter.base()); 3375 assert(ex == "-0***********************"); 3376 assert(ios.width() == 0); 3377 } 3378 ios.width(25); 3379 right(ios); 3380 { 3381 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3382 std::string ex(str, iter.base()); 3383 assert(ex == "***********************-0"); 3384 assert(ios.width() == 0); 3385 } 3386 ios.width(25); 3387 internal(ios); 3388 { 3389 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3390 std::string ex(str, iter.base()); 3391 assert(ex == "-***********************0"); 3392 assert(ios.width() == 0); 3393 } 3394 } 3395 } 3396 showpoint(ios); 3397 { 3398 ios.imbue(lc); 3399 { 3400 ios.width(0); 3401 { 3402 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3403 std::string ex(str, iter.base()); 3404 assert(ex == "-0."); 3405 assert(ios.width() == 0); 3406 } 3407 ios.width(25); 3408 left(ios); 3409 { 3410 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3411 std::string ex(str, iter.base()); 3412 assert(ex == "-0.**********************"); 3413 assert(ios.width() == 0); 3414 } 3415 ios.width(25); 3416 right(ios); 3417 { 3418 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3419 std::string ex(str, iter.base()); 3420 assert(ex == "**********************-0."); 3421 assert(ios.width() == 0); 3422 } 3423 ios.width(25); 3424 internal(ios); 3425 { 3426 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3427 std::string ex(str, iter.base()); 3428 assert(ex == "-**********************0."); 3429 assert(ios.width() == 0); 3430 } 3431 } 3432 ios.imbue(lg); 3433 { 3434 ios.width(0); 3435 { 3436 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3437 std::string ex(str, iter.base()); 3438 assert(ex == "-0;"); 3439 assert(ios.width() == 0); 3440 } 3441 ios.width(25); 3442 left(ios); 3443 { 3444 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3445 std::string ex(str, iter.base()); 3446 assert(ex == "-0;**********************"); 3447 assert(ios.width() == 0); 3448 } 3449 ios.width(25); 3450 right(ios); 3451 { 3452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3453 std::string ex(str, iter.base()); 3454 assert(ex == "**********************-0;"); 3455 assert(ios.width() == 0); 3456 } 3457 ios.width(25); 3458 internal(ios); 3459 { 3460 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3461 std::string ex(str, iter.base()); 3462 assert(ex == "-**********************0;"); 3463 assert(ios.width() == 0); 3464 } 3465 } 3466 } 3467 } 3468 showpos(ios); 3469 { 3470 noshowpoint(ios); 3471 { 3472 ios.imbue(lc); 3473 { 3474 ios.width(0); 3475 { 3476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3477 std::string ex(str, iter.base()); 3478 assert(ex == "-0"); 3479 assert(ios.width() == 0); 3480 } 3481 ios.width(25); 3482 left(ios); 3483 { 3484 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3485 std::string ex(str, iter.base()); 3486 assert(ex == "-0***********************"); 3487 assert(ios.width() == 0); 3488 } 3489 ios.width(25); 3490 right(ios); 3491 { 3492 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3493 std::string ex(str, iter.base()); 3494 assert(ex == "***********************-0"); 3495 assert(ios.width() == 0); 3496 } 3497 ios.width(25); 3498 internal(ios); 3499 { 3500 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3501 std::string ex(str, iter.base()); 3502 assert(ex == "-***********************0"); 3503 assert(ios.width() == 0); 3504 } 3505 } 3506 ios.imbue(lg); 3507 { 3508 ios.width(0); 3509 { 3510 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3511 std::string ex(str, iter.base()); 3512 assert(ex == "-0"); 3513 assert(ios.width() == 0); 3514 } 3515 ios.width(25); 3516 left(ios); 3517 { 3518 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3519 std::string ex(str, iter.base()); 3520 assert(ex == "-0***********************"); 3521 assert(ios.width() == 0); 3522 } 3523 ios.width(25); 3524 right(ios); 3525 { 3526 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3527 std::string ex(str, iter.base()); 3528 assert(ex == "***********************-0"); 3529 assert(ios.width() == 0); 3530 } 3531 ios.width(25); 3532 internal(ios); 3533 { 3534 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3535 std::string ex(str, iter.base()); 3536 assert(ex == "-***********************0"); 3537 assert(ios.width() == 0); 3538 } 3539 } 3540 } 3541 showpoint(ios); 3542 { 3543 ios.imbue(lc); 3544 { 3545 ios.width(0); 3546 { 3547 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3548 std::string ex(str, iter.base()); 3549 assert(ex == "-0."); 3550 assert(ios.width() == 0); 3551 } 3552 ios.width(25); 3553 left(ios); 3554 { 3555 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3556 std::string ex(str, iter.base()); 3557 assert(ex == "-0.**********************"); 3558 assert(ios.width() == 0); 3559 } 3560 ios.width(25); 3561 right(ios); 3562 { 3563 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3564 std::string ex(str, iter.base()); 3565 assert(ex == "**********************-0."); 3566 assert(ios.width() == 0); 3567 } 3568 ios.width(25); 3569 internal(ios); 3570 { 3571 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3572 std::string ex(str, iter.base()); 3573 assert(ex == "-**********************0."); 3574 assert(ios.width() == 0); 3575 } 3576 } 3577 ios.imbue(lg); 3578 { 3579 ios.width(0); 3580 { 3581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3582 std::string ex(str, iter.base()); 3583 assert(ex == "-0;"); 3584 assert(ios.width() == 0); 3585 } 3586 ios.width(25); 3587 left(ios); 3588 { 3589 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3590 std::string ex(str, iter.base()); 3591 assert(ex == "-0;**********************"); 3592 assert(ios.width() == 0); 3593 } 3594 ios.width(25); 3595 right(ios); 3596 { 3597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3598 std::string ex(str, iter.base()); 3599 assert(ex == "**********************-0;"); 3600 assert(ios.width() == 0); 3601 } 3602 ios.width(25); 3603 internal(ios); 3604 { 3605 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3606 std::string ex(str, iter.base()); 3607 assert(ex == "-**********************0;"); 3608 assert(ios.width() == 0); 3609 } 3610 } 3611 } 3612 } 3613 } 3614 } 3615 ios.precision(1); 3616 { 3617 nouppercase(ios); 3618 { 3619 noshowpos(ios); 3620 { 3621 noshowpoint(ios); 3622 { 3623 ios.imbue(lc); 3624 { 3625 ios.width(0); 3626 { 3627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3628 std::string ex(str, iter.base()); 3629 assert(ex == "-0"); 3630 assert(ios.width() == 0); 3631 } 3632 ios.width(25); 3633 left(ios); 3634 { 3635 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3636 std::string ex(str, iter.base()); 3637 assert(ex == "-0***********************"); 3638 assert(ios.width() == 0); 3639 } 3640 ios.width(25); 3641 right(ios); 3642 { 3643 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3644 std::string ex(str, iter.base()); 3645 assert(ex == "***********************-0"); 3646 assert(ios.width() == 0); 3647 } 3648 ios.width(25); 3649 internal(ios); 3650 { 3651 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3652 std::string ex(str, iter.base()); 3653 assert(ex == "-***********************0"); 3654 assert(ios.width() == 0); 3655 } 3656 } 3657 ios.imbue(lg); 3658 { 3659 ios.width(0); 3660 { 3661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3662 std::string ex(str, iter.base()); 3663 assert(ex == "-0"); 3664 assert(ios.width() == 0); 3665 } 3666 ios.width(25); 3667 left(ios); 3668 { 3669 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3670 std::string ex(str, iter.base()); 3671 assert(ex == "-0***********************"); 3672 assert(ios.width() == 0); 3673 } 3674 ios.width(25); 3675 right(ios); 3676 { 3677 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3678 std::string ex(str, iter.base()); 3679 assert(ex == "***********************-0"); 3680 assert(ios.width() == 0); 3681 } 3682 ios.width(25); 3683 internal(ios); 3684 { 3685 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3686 std::string ex(str, iter.base()); 3687 assert(ex == "-***********************0"); 3688 assert(ios.width() == 0); 3689 } 3690 } 3691 } 3692 showpoint(ios); 3693 { 3694 ios.imbue(lc); 3695 { 3696 ios.width(0); 3697 { 3698 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3699 std::string ex(str, iter.base()); 3700 assert(ex == "-0."); 3701 assert(ios.width() == 0); 3702 } 3703 ios.width(25); 3704 left(ios); 3705 { 3706 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3707 std::string ex(str, iter.base()); 3708 assert(ex == "-0.**********************"); 3709 assert(ios.width() == 0); 3710 } 3711 ios.width(25); 3712 right(ios); 3713 { 3714 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3715 std::string ex(str, iter.base()); 3716 assert(ex == "**********************-0."); 3717 assert(ios.width() == 0); 3718 } 3719 ios.width(25); 3720 internal(ios); 3721 { 3722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3723 std::string ex(str, iter.base()); 3724 assert(ex == "-**********************0."); 3725 assert(ios.width() == 0); 3726 } 3727 } 3728 ios.imbue(lg); 3729 { 3730 ios.width(0); 3731 { 3732 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3733 std::string ex(str, iter.base()); 3734 assert(ex == "-0;"); 3735 assert(ios.width() == 0); 3736 } 3737 ios.width(25); 3738 left(ios); 3739 { 3740 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3741 std::string ex(str, iter.base()); 3742 assert(ex == "-0;**********************"); 3743 assert(ios.width() == 0); 3744 } 3745 ios.width(25); 3746 right(ios); 3747 { 3748 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3749 std::string ex(str, iter.base()); 3750 assert(ex == "**********************-0;"); 3751 assert(ios.width() == 0); 3752 } 3753 ios.width(25); 3754 internal(ios); 3755 { 3756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3757 std::string ex(str, iter.base()); 3758 assert(ex == "-**********************0;"); 3759 assert(ios.width() == 0); 3760 } 3761 } 3762 } 3763 } 3764 showpos(ios); 3765 { 3766 noshowpoint(ios); 3767 { 3768 ios.imbue(lc); 3769 { 3770 ios.width(0); 3771 { 3772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3773 std::string ex(str, iter.base()); 3774 assert(ex == "-0"); 3775 assert(ios.width() == 0); 3776 } 3777 ios.width(25); 3778 left(ios); 3779 { 3780 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3781 std::string ex(str, iter.base()); 3782 assert(ex == "-0***********************"); 3783 assert(ios.width() == 0); 3784 } 3785 ios.width(25); 3786 right(ios); 3787 { 3788 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3789 std::string ex(str, iter.base()); 3790 assert(ex == "***********************-0"); 3791 assert(ios.width() == 0); 3792 } 3793 ios.width(25); 3794 internal(ios); 3795 { 3796 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3797 std::string ex(str, iter.base()); 3798 assert(ex == "-***********************0"); 3799 assert(ios.width() == 0); 3800 } 3801 } 3802 ios.imbue(lg); 3803 { 3804 ios.width(0); 3805 { 3806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3807 std::string ex(str, iter.base()); 3808 assert(ex == "-0"); 3809 assert(ios.width() == 0); 3810 } 3811 ios.width(25); 3812 left(ios); 3813 { 3814 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3815 std::string ex(str, iter.base()); 3816 assert(ex == "-0***********************"); 3817 assert(ios.width() == 0); 3818 } 3819 ios.width(25); 3820 right(ios); 3821 { 3822 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3823 std::string ex(str, iter.base()); 3824 assert(ex == "***********************-0"); 3825 assert(ios.width() == 0); 3826 } 3827 ios.width(25); 3828 internal(ios); 3829 { 3830 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3831 std::string ex(str, iter.base()); 3832 assert(ex == "-***********************0"); 3833 assert(ios.width() == 0); 3834 } 3835 } 3836 } 3837 showpoint(ios); 3838 { 3839 ios.imbue(lc); 3840 { 3841 ios.width(0); 3842 { 3843 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3844 std::string ex(str, iter.base()); 3845 assert(ex == "-0."); 3846 assert(ios.width() == 0); 3847 } 3848 ios.width(25); 3849 left(ios); 3850 { 3851 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3852 std::string ex(str, iter.base()); 3853 assert(ex == "-0.**********************"); 3854 assert(ios.width() == 0); 3855 } 3856 ios.width(25); 3857 right(ios); 3858 { 3859 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3860 std::string ex(str, iter.base()); 3861 assert(ex == "**********************-0."); 3862 assert(ios.width() == 0); 3863 } 3864 ios.width(25); 3865 internal(ios); 3866 { 3867 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3868 std::string ex(str, iter.base()); 3869 assert(ex == "-**********************0."); 3870 assert(ios.width() == 0); 3871 } 3872 } 3873 ios.imbue(lg); 3874 { 3875 ios.width(0); 3876 { 3877 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3878 std::string ex(str, iter.base()); 3879 assert(ex == "-0;"); 3880 assert(ios.width() == 0); 3881 } 3882 ios.width(25); 3883 left(ios); 3884 { 3885 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3886 std::string ex(str, iter.base()); 3887 assert(ex == "-0;**********************"); 3888 assert(ios.width() == 0); 3889 } 3890 ios.width(25); 3891 right(ios); 3892 { 3893 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3894 std::string ex(str, iter.base()); 3895 assert(ex == "**********************-0;"); 3896 assert(ios.width() == 0); 3897 } 3898 ios.width(25); 3899 internal(ios); 3900 { 3901 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3902 std::string ex(str, iter.base()); 3903 assert(ex == "-**********************0;"); 3904 assert(ios.width() == 0); 3905 } 3906 } 3907 } 3908 } 3909 } 3910 uppercase(ios); 3911 { 3912 noshowpos(ios); 3913 { 3914 noshowpoint(ios); 3915 { 3916 ios.imbue(lc); 3917 { 3918 ios.width(0); 3919 { 3920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3921 std::string ex(str, iter.base()); 3922 assert(ex == "-0"); 3923 assert(ios.width() == 0); 3924 } 3925 ios.width(25); 3926 left(ios); 3927 { 3928 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3929 std::string ex(str, iter.base()); 3930 assert(ex == "-0***********************"); 3931 assert(ios.width() == 0); 3932 } 3933 ios.width(25); 3934 right(ios); 3935 { 3936 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3937 std::string ex(str, iter.base()); 3938 assert(ex == "***********************-0"); 3939 assert(ios.width() == 0); 3940 } 3941 ios.width(25); 3942 internal(ios); 3943 { 3944 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3945 std::string ex(str, iter.base()); 3946 assert(ex == "-***********************0"); 3947 assert(ios.width() == 0); 3948 } 3949 } 3950 ios.imbue(lg); 3951 { 3952 ios.width(0); 3953 { 3954 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3955 std::string ex(str, iter.base()); 3956 assert(ex == "-0"); 3957 assert(ios.width() == 0); 3958 } 3959 ios.width(25); 3960 left(ios); 3961 { 3962 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3963 std::string ex(str, iter.base()); 3964 assert(ex == "-0***********************"); 3965 assert(ios.width() == 0); 3966 } 3967 ios.width(25); 3968 right(ios); 3969 { 3970 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3971 std::string ex(str, iter.base()); 3972 assert(ex == "***********************-0"); 3973 assert(ios.width() == 0); 3974 } 3975 ios.width(25); 3976 internal(ios); 3977 { 3978 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3979 std::string ex(str, iter.base()); 3980 assert(ex == "-***********************0"); 3981 assert(ios.width() == 0); 3982 } 3983 } 3984 } 3985 showpoint(ios); 3986 { 3987 ios.imbue(lc); 3988 { 3989 ios.width(0); 3990 { 3991 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3992 std::string ex(str, iter.base()); 3993 assert(ex == "-0."); 3994 assert(ios.width() == 0); 3995 } 3996 ios.width(25); 3997 left(ios); 3998 { 3999 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4000 std::string ex(str, iter.base()); 4001 assert(ex == "-0.**********************"); 4002 assert(ios.width() == 0); 4003 } 4004 ios.width(25); 4005 right(ios); 4006 { 4007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4008 std::string ex(str, iter.base()); 4009 assert(ex == "**********************-0."); 4010 assert(ios.width() == 0); 4011 } 4012 ios.width(25); 4013 internal(ios); 4014 { 4015 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4016 std::string ex(str, iter.base()); 4017 assert(ex == "-**********************0."); 4018 assert(ios.width() == 0); 4019 } 4020 } 4021 ios.imbue(lg); 4022 { 4023 ios.width(0); 4024 { 4025 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4026 std::string ex(str, iter.base()); 4027 assert(ex == "-0;"); 4028 assert(ios.width() == 0); 4029 } 4030 ios.width(25); 4031 left(ios); 4032 { 4033 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4034 std::string ex(str, iter.base()); 4035 assert(ex == "-0;**********************"); 4036 assert(ios.width() == 0); 4037 } 4038 ios.width(25); 4039 right(ios); 4040 { 4041 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4042 std::string ex(str, iter.base()); 4043 assert(ex == "**********************-0;"); 4044 assert(ios.width() == 0); 4045 } 4046 ios.width(25); 4047 internal(ios); 4048 { 4049 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4050 std::string ex(str, iter.base()); 4051 assert(ex == "-**********************0;"); 4052 assert(ios.width() == 0); 4053 } 4054 } 4055 } 4056 } 4057 showpos(ios); 4058 { 4059 noshowpoint(ios); 4060 { 4061 ios.imbue(lc); 4062 { 4063 ios.width(0); 4064 { 4065 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4066 std::string ex(str, iter.base()); 4067 assert(ex == "-0"); 4068 assert(ios.width() == 0); 4069 } 4070 ios.width(25); 4071 left(ios); 4072 { 4073 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4074 std::string ex(str, iter.base()); 4075 assert(ex == "-0***********************"); 4076 assert(ios.width() == 0); 4077 } 4078 ios.width(25); 4079 right(ios); 4080 { 4081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4082 std::string ex(str, iter.base()); 4083 assert(ex == "***********************-0"); 4084 assert(ios.width() == 0); 4085 } 4086 ios.width(25); 4087 internal(ios); 4088 { 4089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4090 std::string ex(str, iter.base()); 4091 assert(ex == "-***********************0"); 4092 assert(ios.width() == 0); 4093 } 4094 } 4095 ios.imbue(lg); 4096 { 4097 ios.width(0); 4098 { 4099 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4100 std::string ex(str, iter.base()); 4101 assert(ex == "-0"); 4102 assert(ios.width() == 0); 4103 } 4104 ios.width(25); 4105 left(ios); 4106 { 4107 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4108 std::string ex(str, iter.base()); 4109 assert(ex == "-0***********************"); 4110 assert(ios.width() == 0); 4111 } 4112 ios.width(25); 4113 right(ios); 4114 { 4115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4116 std::string ex(str, iter.base()); 4117 assert(ex == "***********************-0"); 4118 assert(ios.width() == 0); 4119 } 4120 ios.width(25); 4121 internal(ios); 4122 { 4123 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4124 std::string ex(str, iter.base()); 4125 assert(ex == "-***********************0"); 4126 assert(ios.width() == 0); 4127 } 4128 } 4129 } 4130 showpoint(ios); 4131 { 4132 ios.imbue(lc); 4133 { 4134 ios.width(0); 4135 { 4136 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4137 std::string ex(str, iter.base()); 4138 assert(ex == "-0."); 4139 assert(ios.width() == 0); 4140 } 4141 ios.width(25); 4142 left(ios); 4143 { 4144 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4145 std::string ex(str, iter.base()); 4146 assert(ex == "-0.**********************"); 4147 assert(ios.width() == 0); 4148 } 4149 ios.width(25); 4150 right(ios); 4151 { 4152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4153 std::string ex(str, iter.base()); 4154 assert(ex == "**********************-0."); 4155 assert(ios.width() == 0); 4156 } 4157 ios.width(25); 4158 internal(ios); 4159 { 4160 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4161 std::string ex(str, iter.base()); 4162 assert(ex == "-**********************0."); 4163 assert(ios.width() == 0); 4164 } 4165 } 4166 ios.imbue(lg); 4167 { 4168 ios.width(0); 4169 { 4170 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4171 std::string ex(str, iter.base()); 4172 assert(ex == "-0;"); 4173 assert(ios.width() == 0); 4174 } 4175 ios.width(25); 4176 left(ios); 4177 { 4178 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4179 std::string ex(str, iter.base()); 4180 assert(ex == "-0;**********************"); 4181 assert(ios.width() == 0); 4182 } 4183 ios.width(25); 4184 right(ios); 4185 { 4186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4187 std::string ex(str, iter.base()); 4188 assert(ex == "**********************-0;"); 4189 assert(ios.width() == 0); 4190 } 4191 ios.width(25); 4192 internal(ios); 4193 { 4194 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4195 std::string ex(str, iter.base()); 4196 assert(ex == "-**********************0;"); 4197 assert(ios.width() == 0); 4198 } 4199 } 4200 } 4201 } 4202 } 4203 } 4204 ios.precision(6); 4205 { 4206 nouppercase(ios); 4207 { 4208 noshowpos(ios); 4209 { 4210 noshowpoint(ios); 4211 { 4212 ios.imbue(lc); 4213 { 4214 ios.width(0); 4215 { 4216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4217 std::string ex(str, iter.base()); 4218 assert(ex == "-0"); 4219 assert(ios.width() == 0); 4220 } 4221 ios.width(25); 4222 left(ios); 4223 { 4224 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4225 std::string ex(str, iter.base()); 4226 assert(ex == "-0***********************"); 4227 assert(ios.width() == 0); 4228 } 4229 ios.width(25); 4230 right(ios); 4231 { 4232 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4233 std::string ex(str, iter.base()); 4234 assert(ex == "***********************-0"); 4235 assert(ios.width() == 0); 4236 } 4237 ios.width(25); 4238 internal(ios); 4239 { 4240 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4241 std::string ex(str, iter.base()); 4242 assert(ex == "-***********************0"); 4243 assert(ios.width() == 0); 4244 } 4245 } 4246 ios.imbue(lg); 4247 { 4248 ios.width(0); 4249 { 4250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4251 std::string ex(str, iter.base()); 4252 assert(ex == "-0"); 4253 assert(ios.width() == 0); 4254 } 4255 ios.width(25); 4256 left(ios); 4257 { 4258 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4259 std::string ex(str, iter.base()); 4260 assert(ex == "-0***********************"); 4261 assert(ios.width() == 0); 4262 } 4263 ios.width(25); 4264 right(ios); 4265 { 4266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4267 std::string ex(str, iter.base()); 4268 assert(ex == "***********************-0"); 4269 assert(ios.width() == 0); 4270 } 4271 ios.width(25); 4272 internal(ios); 4273 { 4274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4275 std::string ex(str, iter.base()); 4276 assert(ex == "-***********************0"); 4277 assert(ios.width() == 0); 4278 } 4279 } 4280 } 4281 showpoint(ios); 4282 { 4283 ios.imbue(lc); 4284 { 4285 ios.width(0); 4286 { 4287 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4288 std::string ex(str, iter.base()); 4289 assert(ex == "-0.00000"); 4290 assert(ios.width() == 0); 4291 } 4292 ios.width(25); 4293 left(ios); 4294 { 4295 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4296 std::string ex(str, iter.base()); 4297 assert(ex == "-0.00000*****************"); 4298 assert(ios.width() == 0); 4299 } 4300 ios.width(25); 4301 right(ios); 4302 { 4303 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4304 std::string ex(str, iter.base()); 4305 assert(ex == "*****************-0.00000"); 4306 assert(ios.width() == 0); 4307 } 4308 ios.width(25); 4309 internal(ios); 4310 { 4311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4312 std::string ex(str, iter.base()); 4313 assert(ex == "-*****************0.00000"); 4314 assert(ios.width() == 0); 4315 } 4316 } 4317 ios.imbue(lg); 4318 { 4319 ios.width(0); 4320 { 4321 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4322 std::string ex(str, iter.base()); 4323 assert(ex == "-0;00000"); 4324 assert(ios.width() == 0); 4325 } 4326 ios.width(25); 4327 left(ios); 4328 { 4329 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4330 std::string ex(str, iter.base()); 4331 assert(ex == "-0;00000*****************"); 4332 assert(ios.width() == 0); 4333 } 4334 ios.width(25); 4335 right(ios); 4336 { 4337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4338 std::string ex(str, iter.base()); 4339 assert(ex == "*****************-0;00000"); 4340 assert(ios.width() == 0); 4341 } 4342 ios.width(25); 4343 internal(ios); 4344 { 4345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4346 std::string ex(str, iter.base()); 4347 assert(ex == "-*****************0;00000"); 4348 assert(ios.width() == 0); 4349 } 4350 } 4351 } 4352 } 4353 showpos(ios); 4354 { 4355 noshowpoint(ios); 4356 { 4357 ios.imbue(lc); 4358 { 4359 ios.width(0); 4360 { 4361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4362 std::string ex(str, iter.base()); 4363 assert(ex == "-0"); 4364 assert(ios.width() == 0); 4365 } 4366 ios.width(25); 4367 left(ios); 4368 { 4369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4370 std::string ex(str, iter.base()); 4371 assert(ex == "-0***********************"); 4372 assert(ios.width() == 0); 4373 } 4374 ios.width(25); 4375 right(ios); 4376 { 4377 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4378 std::string ex(str, iter.base()); 4379 assert(ex == "***********************-0"); 4380 assert(ios.width() == 0); 4381 } 4382 ios.width(25); 4383 internal(ios); 4384 { 4385 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4386 std::string ex(str, iter.base()); 4387 assert(ex == "-***********************0"); 4388 assert(ios.width() == 0); 4389 } 4390 } 4391 ios.imbue(lg); 4392 { 4393 ios.width(0); 4394 { 4395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4396 std::string ex(str, iter.base()); 4397 assert(ex == "-0"); 4398 assert(ios.width() == 0); 4399 } 4400 ios.width(25); 4401 left(ios); 4402 { 4403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4404 std::string ex(str, iter.base()); 4405 assert(ex == "-0***********************"); 4406 assert(ios.width() == 0); 4407 } 4408 ios.width(25); 4409 right(ios); 4410 { 4411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4412 std::string ex(str, iter.base()); 4413 assert(ex == "***********************-0"); 4414 assert(ios.width() == 0); 4415 } 4416 ios.width(25); 4417 internal(ios); 4418 { 4419 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4420 std::string ex(str, iter.base()); 4421 assert(ex == "-***********************0"); 4422 assert(ios.width() == 0); 4423 } 4424 } 4425 } 4426 showpoint(ios); 4427 { 4428 ios.imbue(lc); 4429 { 4430 ios.width(0); 4431 { 4432 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4433 std::string ex(str, iter.base()); 4434 assert(ex == "-0.00000"); 4435 assert(ios.width() == 0); 4436 } 4437 ios.width(25); 4438 left(ios); 4439 { 4440 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4441 std::string ex(str, iter.base()); 4442 assert(ex == "-0.00000*****************"); 4443 assert(ios.width() == 0); 4444 } 4445 ios.width(25); 4446 right(ios); 4447 { 4448 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4449 std::string ex(str, iter.base()); 4450 assert(ex == "*****************-0.00000"); 4451 assert(ios.width() == 0); 4452 } 4453 ios.width(25); 4454 internal(ios); 4455 { 4456 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4457 std::string ex(str, iter.base()); 4458 assert(ex == "-*****************0.00000"); 4459 assert(ios.width() == 0); 4460 } 4461 } 4462 ios.imbue(lg); 4463 { 4464 ios.width(0); 4465 { 4466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4467 std::string ex(str, iter.base()); 4468 assert(ex == "-0;00000"); 4469 assert(ios.width() == 0); 4470 } 4471 ios.width(25); 4472 left(ios); 4473 { 4474 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4475 std::string ex(str, iter.base()); 4476 assert(ex == "-0;00000*****************"); 4477 assert(ios.width() == 0); 4478 } 4479 ios.width(25); 4480 right(ios); 4481 { 4482 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4483 std::string ex(str, iter.base()); 4484 assert(ex == "*****************-0;00000"); 4485 assert(ios.width() == 0); 4486 } 4487 ios.width(25); 4488 internal(ios); 4489 { 4490 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4491 std::string ex(str, iter.base()); 4492 assert(ex == "-*****************0;00000"); 4493 assert(ios.width() == 0); 4494 } 4495 } 4496 } 4497 } 4498 } 4499 uppercase(ios); 4500 { 4501 noshowpos(ios); 4502 { 4503 noshowpoint(ios); 4504 { 4505 ios.imbue(lc); 4506 { 4507 ios.width(0); 4508 { 4509 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4510 std::string ex(str, iter.base()); 4511 assert(ex == "-0"); 4512 assert(ios.width() == 0); 4513 } 4514 ios.width(25); 4515 left(ios); 4516 { 4517 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4518 std::string ex(str, iter.base()); 4519 assert(ex == "-0***********************"); 4520 assert(ios.width() == 0); 4521 } 4522 ios.width(25); 4523 right(ios); 4524 { 4525 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4526 std::string ex(str, iter.base()); 4527 assert(ex == "***********************-0"); 4528 assert(ios.width() == 0); 4529 } 4530 ios.width(25); 4531 internal(ios); 4532 { 4533 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4534 std::string ex(str, iter.base()); 4535 assert(ex == "-***********************0"); 4536 assert(ios.width() == 0); 4537 } 4538 } 4539 ios.imbue(lg); 4540 { 4541 ios.width(0); 4542 { 4543 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4544 std::string ex(str, iter.base()); 4545 assert(ex == "-0"); 4546 assert(ios.width() == 0); 4547 } 4548 ios.width(25); 4549 left(ios); 4550 { 4551 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4552 std::string ex(str, iter.base()); 4553 assert(ex == "-0***********************"); 4554 assert(ios.width() == 0); 4555 } 4556 ios.width(25); 4557 right(ios); 4558 { 4559 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4560 std::string ex(str, iter.base()); 4561 assert(ex == "***********************-0"); 4562 assert(ios.width() == 0); 4563 } 4564 ios.width(25); 4565 internal(ios); 4566 { 4567 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4568 std::string ex(str, iter.base()); 4569 assert(ex == "-***********************0"); 4570 assert(ios.width() == 0); 4571 } 4572 } 4573 } 4574 showpoint(ios); 4575 { 4576 ios.imbue(lc); 4577 { 4578 ios.width(0); 4579 { 4580 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4581 std::string ex(str, iter.base()); 4582 assert(ex == "-0.00000"); 4583 assert(ios.width() == 0); 4584 } 4585 ios.width(25); 4586 left(ios); 4587 { 4588 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4589 std::string ex(str, iter.base()); 4590 assert(ex == "-0.00000*****************"); 4591 assert(ios.width() == 0); 4592 } 4593 ios.width(25); 4594 right(ios); 4595 { 4596 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4597 std::string ex(str, iter.base()); 4598 assert(ex == "*****************-0.00000"); 4599 assert(ios.width() == 0); 4600 } 4601 ios.width(25); 4602 internal(ios); 4603 { 4604 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4605 std::string ex(str, iter.base()); 4606 assert(ex == "-*****************0.00000"); 4607 assert(ios.width() == 0); 4608 } 4609 } 4610 ios.imbue(lg); 4611 { 4612 ios.width(0); 4613 { 4614 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4615 std::string ex(str, iter.base()); 4616 assert(ex == "-0;00000"); 4617 assert(ios.width() == 0); 4618 } 4619 ios.width(25); 4620 left(ios); 4621 { 4622 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4623 std::string ex(str, iter.base()); 4624 assert(ex == "-0;00000*****************"); 4625 assert(ios.width() == 0); 4626 } 4627 ios.width(25); 4628 right(ios); 4629 { 4630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4631 std::string ex(str, iter.base()); 4632 assert(ex == "*****************-0;00000"); 4633 assert(ios.width() == 0); 4634 } 4635 ios.width(25); 4636 internal(ios); 4637 { 4638 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4639 std::string ex(str, iter.base()); 4640 assert(ex == "-*****************0;00000"); 4641 assert(ios.width() == 0); 4642 } 4643 } 4644 } 4645 } 4646 showpos(ios); 4647 { 4648 noshowpoint(ios); 4649 { 4650 ios.imbue(lc); 4651 { 4652 ios.width(0); 4653 { 4654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4655 std::string ex(str, iter.base()); 4656 assert(ex == "-0"); 4657 assert(ios.width() == 0); 4658 } 4659 ios.width(25); 4660 left(ios); 4661 { 4662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4663 std::string ex(str, iter.base()); 4664 assert(ex == "-0***********************"); 4665 assert(ios.width() == 0); 4666 } 4667 ios.width(25); 4668 right(ios); 4669 { 4670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4671 std::string ex(str, iter.base()); 4672 assert(ex == "***********************-0"); 4673 assert(ios.width() == 0); 4674 } 4675 ios.width(25); 4676 internal(ios); 4677 { 4678 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4679 std::string ex(str, iter.base()); 4680 assert(ex == "-***********************0"); 4681 assert(ios.width() == 0); 4682 } 4683 } 4684 ios.imbue(lg); 4685 { 4686 ios.width(0); 4687 { 4688 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4689 std::string ex(str, iter.base()); 4690 assert(ex == "-0"); 4691 assert(ios.width() == 0); 4692 } 4693 ios.width(25); 4694 left(ios); 4695 { 4696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4697 std::string ex(str, iter.base()); 4698 assert(ex == "-0***********************"); 4699 assert(ios.width() == 0); 4700 } 4701 ios.width(25); 4702 right(ios); 4703 { 4704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4705 std::string ex(str, iter.base()); 4706 assert(ex == "***********************-0"); 4707 assert(ios.width() == 0); 4708 } 4709 ios.width(25); 4710 internal(ios); 4711 { 4712 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4713 std::string ex(str, iter.base()); 4714 assert(ex == "-***********************0"); 4715 assert(ios.width() == 0); 4716 } 4717 } 4718 } 4719 showpoint(ios); 4720 { 4721 ios.imbue(lc); 4722 { 4723 ios.width(0); 4724 { 4725 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4726 std::string ex(str, iter.base()); 4727 assert(ex == "-0.00000"); 4728 assert(ios.width() == 0); 4729 } 4730 ios.width(25); 4731 left(ios); 4732 { 4733 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4734 std::string ex(str, iter.base()); 4735 assert(ex == "-0.00000*****************"); 4736 assert(ios.width() == 0); 4737 } 4738 ios.width(25); 4739 right(ios); 4740 { 4741 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4742 std::string ex(str, iter.base()); 4743 assert(ex == "*****************-0.00000"); 4744 assert(ios.width() == 0); 4745 } 4746 ios.width(25); 4747 internal(ios); 4748 { 4749 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4750 std::string ex(str, iter.base()); 4751 assert(ex == "-*****************0.00000"); 4752 assert(ios.width() == 0); 4753 } 4754 } 4755 ios.imbue(lg); 4756 { 4757 ios.width(0); 4758 { 4759 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4760 std::string ex(str, iter.base()); 4761 assert(ex == "-0;00000"); 4762 assert(ios.width() == 0); 4763 } 4764 ios.width(25); 4765 left(ios); 4766 { 4767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4768 std::string ex(str, iter.base()); 4769 assert(ex == "-0;00000*****************"); 4770 assert(ios.width() == 0); 4771 } 4772 ios.width(25); 4773 right(ios); 4774 { 4775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4776 std::string ex(str, iter.base()); 4777 assert(ex == "*****************-0;00000"); 4778 assert(ios.width() == 0); 4779 } 4780 ios.width(25); 4781 internal(ios); 4782 { 4783 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4784 std::string ex(str, iter.base()); 4785 assert(ex == "-*****************0;00000"); 4786 assert(ios.width() == 0); 4787 } 4788 } 4789 } 4790 } 4791 } 4792 } 4793 ios.precision(16); 4794 { 4795 nouppercase(ios); 4796 { 4797 noshowpos(ios); 4798 { 4799 noshowpoint(ios); 4800 { 4801 ios.imbue(lc); 4802 { 4803 ios.width(0); 4804 { 4805 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4806 std::string ex(str, iter.base()); 4807 assert(ex == "-0"); 4808 assert(ios.width() == 0); 4809 } 4810 ios.width(25); 4811 left(ios); 4812 { 4813 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4814 std::string ex(str, iter.base()); 4815 assert(ex == "-0***********************"); 4816 assert(ios.width() == 0); 4817 } 4818 ios.width(25); 4819 right(ios); 4820 { 4821 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4822 std::string ex(str, iter.base()); 4823 assert(ex == "***********************-0"); 4824 assert(ios.width() == 0); 4825 } 4826 ios.width(25); 4827 internal(ios); 4828 { 4829 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4830 std::string ex(str, iter.base()); 4831 assert(ex == "-***********************0"); 4832 assert(ios.width() == 0); 4833 } 4834 } 4835 ios.imbue(lg); 4836 { 4837 ios.width(0); 4838 { 4839 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4840 std::string ex(str, iter.base()); 4841 assert(ex == "-0"); 4842 assert(ios.width() == 0); 4843 } 4844 ios.width(25); 4845 left(ios); 4846 { 4847 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4848 std::string ex(str, iter.base()); 4849 assert(ex == "-0***********************"); 4850 assert(ios.width() == 0); 4851 } 4852 ios.width(25); 4853 right(ios); 4854 { 4855 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4856 std::string ex(str, iter.base()); 4857 assert(ex == "***********************-0"); 4858 assert(ios.width() == 0); 4859 } 4860 ios.width(25); 4861 internal(ios); 4862 { 4863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4864 std::string ex(str, iter.base()); 4865 assert(ex == "-***********************0"); 4866 assert(ios.width() == 0); 4867 } 4868 } 4869 } 4870 showpoint(ios); 4871 { 4872 ios.imbue(lc); 4873 { 4874 ios.width(0); 4875 { 4876 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4877 std::string ex(str, iter.base()); 4878 assert(ex == "-0.000000000000000"); 4879 assert(ios.width() == 0); 4880 } 4881 ios.width(25); 4882 left(ios); 4883 { 4884 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4885 std::string ex(str, iter.base()); 4886 assert(ex == "-0.000000000000000*******"); 4887 assert(ios.width() == 0); 4888 } 4889 ios.width(25); 4890 right(ios); 4891 { 4892 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4893 std::string ex(str, iter.base()); 4894 assert(ex == "*******-0.000000000000000"); 4895 assert(ios.width() == 0); 4896 } 4897 ios.width(25); 4898 internal(ios); 4899 { 4900 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4901 std::string ex(str, iter.base()); 4902 assert(ex == "-*******0.000000000000000"); 4903 assert(ios.width() == 0); 4904 } 4905 } 4906 ios.imbue(lg); 4907 { 4908 ios.width(0); 4909 { 4910 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4911 std::string ex(str, iter.base()); 4912 assert(ex == "-0;000000000000000"); 4913 assert(ios.width() == 0); 4914 } 4915 ios.width(25); 4916 left(ios); 4917 { 4918 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4919 std::string ex(str, iter.base()); 4920 assert(ex == "-0;000000000000000*******"); 4921 assert(ios.width() == 0); 4922 } 4923 ios.width(25); 4924 right(ios); 4925 { 4926 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4927 std::string ex(str, iter.base()); 4928 assert(ex == "*******-0;000000000000000"); 4929 assert(ios.width() == 0); 4930 } 4931 ios.width(25); 4932 internal(ios); 4933 { 4934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4935 std::string ex(str, iter.base()); 4936 assert(ex == "-*******0;000000000000000"); 4937 assert(ios.width() == 0); 4938 } 4939 } 4940 } 4941 } 4942 showpos(ios); 4943 { 4944 noshowpoint(ios); 4945 { 4946 ios.imbue(lc); 4947 { 4948 ios.width(0); 4949 { 4950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4951 std::string ex(str, iter.base()); 4952 assert(ex == "-0"); 4953 assert(ios.width() == 0); 4954 } 4955 ios.width(25); 4956 left(ios); 4957 { 4958 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4959 std::string ex(str, iter.base()); 4960 assert(ex == "-0***********************"); 4961 assert(ios.width() == 0); 4962 } 4963 ios.width(25); 4964 right(ios); 4965 { 4966 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4967 std::string ex(str, iter.base()); 4968 assert(ex == "***********************-0"); 4969 assert(ios.width() == 0); 4970 } 4971 ios.width(25); 4972 internal(ios); 4973 { 4974 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4975 std::string ex(str, iter.base()); 4976 assert(ex == "-***********************0"); 4977 assert(ios.width() == 0); 4978 } 4979 } 4980 ios.imbue(lg); 4981 { 4982 ios.width(0); 4983 { 4984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4985 std::string ex(str, iter.base()); 4986 assert(ex == "-0"); 4987 assert(ios.width() == 0); 4988 } 4989 ios.width(25); 4990 left(ios); 4991 { 4992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4993 std::string ex(str, iter.base()); 4994 assert(ex == "-0***********************"); 4995 assert(ios.width() == 0); 4996 } 4997 ios.width(25); 4998 right(ios); 4999 { 5000 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5001 std::string ex(str, iter.base()); 5002 assert(ex == "***********************-0"); 5003 assert(ios.width() == 0); 5004 } 5005 ios.width(25); 5006 internal(ios); 5007 { 5008 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5009 std::string ex(str, iter.base()); 5010 assert(ex == "-***********************0"); 5011 assert(ios.width() == 0); 5012 } 5013 } 5014 } 5015 showpoint(ios); 5016 { 5017 ios.imbue(lc); 5018 { 5019 ios.width(0); 5020 { 5021 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5022 std::string ex(str, iter.base()); 5023 assert(ex == "-0.000000000000000"); 5024 assert(ios.width() == 0); 5025 } 5026 ios.width(25); 5027 left(ios); 5028 { 5029 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5030 std::string ex(str, iter.base()); 5031 assert(ex == "-0.000000000000000*******"); 5032 assert(ios.width() == 0); 5033 } 5034 ios.width(25); 5035 right(ios); 5036 { 5037 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5038 std::string ex(str, iter.base()); 5039 assert(ex == "*******-0.000000000000000"); 5040 assert(ios.width() == 0); 5041 } 5042 ios.width(25); 5043 internal(ios); 5044 { 5045 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5046 std::string ex(str, iter.base()); 5047 assert(ex == "-*******0.000000000000000"); 5048 assert(ios.width() == 0); 5049 } 5050 } 5051 ios.imbue(lg); 5052 { 5053 ios.width(0); 5054 { 5055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5056 std::string ex(str, iter.base()); 5057 assert(ex == "-0;000000000000000"); 5058 assert(ios.width() == 0); 5059 } 5060 ios.width(25); 5061 left(ios); 5062 { 5063 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5064 std::string ex(str, iter.base()); 5065 assert(ex == "-0;000000000000000*******"); 5066 assert(ios.width() == 0); 5067 } 5068 ios.width(25); 5069 right(ios); 5070 { 5071 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5072 std::string ex(str, iter.base()); 5073 assert(ex == "*******-0;000000000000000"); 5074 assert(ios.width() == 0); 5075 } 5076 ios.width(25); 5077 internal(ios); 5078 { 5079 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5080 std::string ex(str, iter.base()); 5081 assert(ex == "-*******0;000000000000000"); 5082 assert(ios.width() == 0); 5083 } 5084 } 5085 } 5086 } 5087 } 5088 uppercase(ios); 5089 { 5090 noshowpos(ios); 5091 { 5092 noshowpoint(ios); 5093 { 5094 ios.imbue(lc); 5095 { 5096 ios.width(0); 5097 { 5098 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5099 std::string ex(str, iter.base()); 5100 assert(ex == "-0"); 5101 assert(ios.width() == 0); 5102 } 5103 ios.width(25); 5104 left(ios); 5105 { 5106 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5107 std::string ex(str, iter.base()); 5108 assert(ex == "-0***********************"); 5109 assert(ios.width() == 0); 5110 } 5111 ios.width(25); 5112 right(ios); 5113 { 5114 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5115 std::string ex(str, iter.base()); 5116 assert(ex == "***********************-0"); 5117 assert(ios.width() == 0); 5118 } 5119 ios.width(25); 5120 internal(ios); 5121 { 5122 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5123 std::string ex(str, iter.base()); 5124 assert(ex == "-***********************0"); 5125 assert(ios.width() == 0); 5126 } 5127 } 5128 ios.imbue(lg); 5129 { 5130 ios.width(0); 5131 { 5132 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5133 std::string ex(str, iter.base()); 5134 assert(ex == "-0"); 5135 assert(ios.width() == 0); 5136 } 5137 ios.width(25); 5138 left(ios); 5139 { 5140 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5141 std::string ex(str, iter.base()); 5142 assert(ex == "-0***********************"); 5143 assert(ios.width() == 0); 5144 } 5145 ios.width(25); 5146 right(ios); 5147 { 5148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5149 std::string ex(str, iter.base()); 5150 assert(ex == "***********************-0"); 5151 assert(ios.width() == 0); 5152 } 5153 ios.width(25); 5154 internal(ios); 5155 { 5156 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5157 std::string ex(str, iter.base()); 5158 assert(ex == "-***********************0"); 5159 assert(ios.width() == 0); 5160 } 5161 } 5162 } 5163 showpoint(ios); 5164 { 5165 ios.imbue(lc); 5166 { 5167 ios.width(0); 5168 { 5169 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5170 std::string ex(str, iter.base()); 5171 assert(ex == "-0.000000000000000"); 5172 assert(ios.width() == 0); 5173 } 5174 ios.width(25); 5175 left(ios); 5176 { 5177 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5178 std::string ex(str, iter.base()); 5179 assert(ex == "-0.000000000000000*******"); 5180 assert(ios.width() == 0); 5181 } 5182 ios.width(25); 5183 right(ios); 5184 { 5185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5186 std::string ex(str, iter.base()); 5187 assert(ex == "*******-0.000000000000000"); 5188 assert(ios.width() == 0); 5189 } 5190 ios.width(25); 5191 internal(ios); 5192 { 5193 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5194 std::string ex(str, iter.base()); 5195 assert(ex == "-*******0.000000000000000"); 5196 assert(ios.width() == 0); 5197 } 5198 } 5199 ios.imbue(lg); 5200 { 5201 ios.width(0); 5202 { 5203 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5204 std::string ex(str, iter.base()); 5205 assert(ex == "-0;000000000000000"); 5206 assert(ios.width() == 0); 5207 } 5208 ios.width(25); 5209 left(ios); 5210 { 5211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5212 std::string ex(str, iter.base()); 5213 assert(ex == "-0;000000000000000*******"); 5214 assert(ios.width() == 0); 5215 } 5216 ios.width(25); 5217 right(ios); 5218 { 5219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5220 std::string ex(str, iter.base()); 5221 assert(ex == "*******-0;000000000000000"); 5222 assert(ios.width() == 0); 5223 } 5224 ios.width(25); 5225 internal(ios); 5226 { 5227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5228 std::string ex(str, iter.base()); 5229 assert(ex == "-*******0;000000000000000"); 5230 assert(ios.width() == 0); 5231 } 5232 } 5233 } 5234 } 5235 showpos(ios); 5236 { 5237 noshowpoint(ios); 5238 { 5239 ios.imbue(lc); 5240 { 5241 ios.width(0); 5242 { 5243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5244 std::string ex(str, iter.base()); 5245 assert(ex == "-0"); 5246 assert(ios.width() == 0); 5247 } 5248 ios.width(25); 5249 left(ios); 5250 { 5251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5252 std::string ex(str, iter.base()); 5253 assert(ex == "-0***********************"); 5254 assert(ios.width() == 0); 5255 } 5256 ios.width(25); 5257 right(ios); 5258 { 5259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5260 std::string ex(str, iter.base()); 5261 assert(ex == "***********************-0"); 5262 assert(ios.width() == 0); 5263 } 5264 ios.width(25); 5265 internal(ios); 5266 { 5267 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5268 std::string ex(str, iter.base()); 5269 assert(ex == "-***********************0"); 5270 assert(ios.width() == 0); 5271 } 5272 } 5273 ios.imbue(lg); 5274 { 5275 ios.width(0); 5276 { 5277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5278 std::string ex(str, iter.base()); 5279 assert(ex == "-0"); 5280 assert(ios.width() == 0); 5281 } 5282 ios.width(25); 5283 left(ios); 5284 { 5285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5286 std::string ex(str, iter.base()); 5287 assert(ex == "-0***********************"); 5288 assert(ios.width() == 0); 5289 } 5290 ios.width(25); 5291 right(ios); 5292 { 5293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5294 std::string ex(str, iter.base()); 5295 assert(ex == "***********************-0"); 5296 assert(ios.width() == 0); 5297 } 5298 ios.width(25); 5299 internal(ios); 5300 { 5301 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5302 std::string ex(str, iter.base()); 5303 assert(ex == "-***********************0"); 5304 assert(ios.width() == 0); 5305 } 5306 } 5307 } 5308 showpoint(ios); 5309 { 5310 ios.imbue(lc); 5311 { 5312 ios.width(0); 5313 { 5314 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5315 std::string ex(str, iter.base()); 5316 assert(ex == "-0.000000000000000"); 5317 assert(ios.width() == 0); 5318 } 5319 ios.width(25); 5320 left(ios); 5321 { 5322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5323 std::string ex(str, iter.base()); 5324 assert(ex == "-0.000000000000000*******"); 5325 assert(ios.width() == 0); 5326 } 5327 ios.width(25); 5328 right(ios); 5329 { 5330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5331 std::string ex(str, iter.base()); 5332 assert(ex == "*******-0.000000000000000"); 5333 assert(ios.width() == 0); 5334 } 5335 ios.width(25); 5336 internal(ios); 5337 { 5338 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5339 std::string ex(str, iter.base()); 5340 assert(ex == "-*******0.000000000000000"); 5341 assert(ios.width() == 0); 5342 } 5343 } 5344 ios.imbue(lg); 5345 { 5346 ios.width(0); 5347 { 5348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5349 std::string ex(str, iter.base()); 5350 assert(ex == "-0;000000000000000"); 5351 assert(ios.width() == 0); 5352 } 5353 ios.width(25); 5354 left(ios); 5355 { 5356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5357 std::string ex(str, iter.base()); 5358 assert(ex == "-0;000000000000000*******"); 5359 assert(ios.width() == 0); 5360 } 5361 ios.width(25); 5362 right(ios); 5363 { 5364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5365 std::string ex(str, iter.base()); 5366 assert(ex == "*******-0;000000000000000"); 5367 assert(ios.width() == 0); 5368 } 5369 ios.width(25); 5370 internal(ios); 5371 { 5372 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5373 std::string ex(str, iter.base()); 5374 assert(ex == "-*******0;000000000000000"); 5375 assert(ios.width() == 0); 5376 } 5377 } 5378 } 5379 } 5380 } 5381 } 5382 ios.precision(60); 5383 { 5384 nouppercase(ios); 5385 { 5386 noshowpos(ios); 5387 { 5388 noshowpoint(ios); 5389 { 5390 ios.imbue(lc); 5391 { 5392 ios.width(0); 5393 { 5394 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5395 std::string ex(str, iter.base()); 5396 assert(ex == "-0"); 5397 assert(ios.width() == 0); 5398 } 5399 ios.width(25); 5400 left(ios); 5401 { 5402 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5403 std::string ex(str, iter.base()); 5404 assert(ex == "-0***********************"); 5405 assert(ios.width() == 0); 5406 } 5407 ios.width(25); 5408 right(ios); 5409 { 5410 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5411 std::string ex(str, iter.base()); 5412 assert(ex == "***********************-0"); 5413 assert(ios.width() == 0); 5414 } 5415 ios.width(25); 5416 internal(ios); 5417 { 5418 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5419 std::string ex(str, iter.base()); 5420 assert(ex == "-***********************0"); 5421 assert(ios.width() == 0); 5422 } 5423 } 5424 ios.imbue(lg); 5425 { 5426 ios.width(0); 5427 { 5428 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5429 std::string ex(str, iter.base()); 5430 assert(ex == "-0"); 5431 assert(ios.width() == 0); 5432 } 5433 ios.width(25); 5434 left(ios); 5435 { 5436 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5437 std::string ex(str, iter.base()); 5438 assert(ex == "-0***********************"); 5439 assert(ios.width() == 0); 5440 } 5441 ios.width(25); 5442 right(ios); 5443 { 5444 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5445 std::string ex(str, iter.base()); 5446 assert(ex == "***********************-0"); 5447 assert(ios.width() == 0); 5448 } 5449 ios.width(25); 5450 internal(ios); 5451 { 5452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5453 std::string ex(str, iter.base()); 5454 assert(ex == "-***********************0"); 5455 assert(ios.width() == 0); 5456 } 5457 } 5458 } 5459 showpoint(ios); 5460 { 5461 ios.imbue(lc); 5462 { 5463 ios.width(0); 5464 { 5465 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5466 std::string ex(str, iter.base()); 5467 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5468 assert(ios.width() == 0); 5469 } 5470 ios.width(25); 5471 left(ios); 5472 { 5473 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5474 std::string ex(str, iter.base()); 5475 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5476 assert(ios.width() == 0); 5477 } 5478 ios.width(25); 5479 right(ios); 5480 { 5481 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5482 std::string ex(str, iter.base()); 5483 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5484 assert(ios.width() == 0); 5485 } 5486 ios.width(25); 5487 internal(ios); 5488 { 5489 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5490 std::string ex(str, iter.base()); 5491 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5492 assert(ios.width() == 0); 5493 } 5494 } 5495 ios.imbue(lg); 5496 { 5497 ios.width(0); 5498 { 5499 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5500 std::string ex(str, iter.base()); 5501 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5502 assert(ios.width() == 0); 5503 } 5504 ios.width(25); 5505 left(ios); 5506 { 5507 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5508 std::string ex(str, iter.base()); 5509 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5510 assert(ios.width() == 0); 5511 } 5512 ios.width(25); 5513 right(ios); 5514 { 5515 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5516 std::string ex(str, iter.base()); 5517 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5518 assert(ios.width() == 0); 5519 } 5520 ios.width(25); 5521 internal(ios); 5522 { 5523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5524 std::string ex(str, iter.base()); 5525 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5526 assert(ios.width() == 0); 5527 } 5528 } 5529 } 5530 } 5531 showpos(ios); 5532 { 5533 noshowpoint(ios); 5534 { 5535 ios.imbue(lc); 5536 { 5537 ios.width(0); 5538 { 5539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5540 std::string ex(str, iter.base()); 5541 assert(ex == "-0"); 5542 assert(ios.width() == 0); 5543 } 5544 ios.width(25); 5545 left(ios); 5546 { 5547 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5548 std::string ex(str, iter.base()); 5549 assert(ex == "-0***********************"); 5550 assert(ios.width() == 0); 5551 } 5552 ios.width(25); 5553 right(ios); 5554 { 5555 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5556 std::string ex(str, iter.base()); 5557 assert(ex == "***********************-0"); 5558 assert(ios.width() == 0); 5559 } 5560 ios.width(25); 5561 internal(ios); 5562 { 5563 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5564 std::string ex(str, iter.base()); 5565 assert(ex == "-***********************0"); 5566 assert(ios.width() == 0); 5567 } 5568 } 5569 ios.imbue(lg); 5570 { 5571 ios.width(0); 5572 { 5573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5574 std::string ex(str, iter.base()); 5575 assert(ex == "-0"); 5576 assert(ios.width() == 0); 5577 } 5578 ios.width(25); 5579 left(ios); 5580 { 5581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5582 std::string ex(str, iter.base()); 5583 assert(ex == "-0***********************"); 5584 assert(ios.width() == 0); 5585 } 5586 ios.width(25); 5587 right(ios); 5588 { 5589 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5590 std::string ex(str, iter.base()); 5591 assert(ex == "***********************-0"); 5592 assert(ios.width() == 0); 5593 } 5594 ios.width(25); 5595 internal(ios); 5596 { 5597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5598 std::string ex(str, iter.base()); 5599 assert(ex == "-***********************0"); 5600 assert(ios.width() == 0); 5601 } 5602 } 5603 } 5604 showpoint(ios); 5605 { 5606 ios.imbue(lc); 5607 { 5608 ios.width(0); 5609 { 5610 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5611 std::string ex(str, iter.base()); 5612 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5613 assert(ios.width() == 0); 5614 } 5615 ios.width(25); 5616 left(ios); 5617 { 5618 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5619 std::string ex(str, iter.base()); 5620 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5621 assert(ios.width() == 0); 5622 } 5623 ios.width(25); 5624 right(ios); 5625 { 5626 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5627 std::string ex(str, iter.base()); 5628 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5629 assert(ios.width() == 0); 5630 } 5631 ios.width(25); 5632 internal(ios); 5633 { 5634 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5635 std::string ex(str, iter.base()); 5636 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5637 assert(ios.width() == 0); 5638 } 5639 } 5640 ios.imbue(lg); 5641 { 5642 ios.width(0); 5643 { 5644 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5645 std::string ex(str, iter.base()); 5646 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5647 assert(ios.width() == 0); 5648 } 5649 ios.width(25); 5650 left(ios); 5651 { 5652 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5653 std::string ex(str, iter.base()); 5654 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5655 assert(ios.width() == 0); 5656 } 5657 ios.width(25); 5658 right(ios); 5659 { 5660 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5661 std::string ex(str, iter.base()); 5662 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5663 assert(ios.width() == 0); 5664 } 5665 ios.width(25); 5666 internal(ios); 5667 { 5668 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5669 std::string ex(str, iter.base()); 5670 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5671 assert(ios.width() == 0); 5672 } 5673 } 5674 } 5675 } 5676 } 5677 uppercase(ios); 5678 { 5679 noshowpos(ios); 5680 { 5681 noshowpoint(ios); 5682 { 5683 ios.imbue(lc); 5684 { 5685 ios.width(0); 5686 { 5687 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5688 std::string ex(str, iter.base()); 5689 assert(ex == "-0"); 5690 assert(ios.width() == 0); 5691 } 5692 ios.width(25); 5693 left(ios); 5694 { 5695 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5696 std::string ex(str, iter.base()); 5697 assert(ex == "-0***********************"); 5698 assert(ios.width() == 0); 5699 } 5700 ios.width(25); 5701 right(ios); 5702 { 5703 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5704 std::string ex(str, iter.base()); 5705 assert(ex == "***********************-0"); 5706 assert(ios.width() == 0); 5707 } 5708 ios.width(25); 5709 internal(ios); 5710 { 5711 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5712 std::string ex(str, iter.base()); 5713 assert(ex == "-***********************0"); 5714 assert(ios.width() == 0); 5715 } 5716 } 5717 ios.imbue(lg); 5718 { 5719 ios.width(0); 5720 { 5721 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5722 std::string ex(str, iter.base()); 5723 assert(ex == "-0"); 5724 assert(ios.width() == 0); 5725 } 5726 ios.width(25); 5727 left(ios); 5728 { 5729 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5730 std::string ex(str, iter.base()); 5731 assert(ex == "-0***********************"); 5732 assert(ios.width() == 0); 5733 } 5734 ios.width(25); 5735 right(ios); 5736 { 5737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5738 std::string ex(str, iter.base()); 5739 assert(ex == "***********************-0"); 5740 assert(ios.width() == 0); 5741 } 5742 ios.width(25); 5743 internal(ios); 5744 { 5745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5746 std::string ex(str, iter.base()); 5747 assert(ex == "-***********************0"); 5748 assert(ios.width() == 0); 5749 } 5750 } 5751 } 5752 showpoint(ios); 5753 { 5754 ios.imbue(lc); 5755 { 5756 ios.width(0); 5757 { 5758 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5759 std::string ex(str, iter.base()); 5760 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5761 assert(ios.width() == 0); 5762 } 5763 ios.width(25); 5764 left(ios); 5765 { 5766 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5767 std::string ex(str, iter.base()); 5768 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5769 assert(ios.width() == 0); 5770 } 5771 ios.width(25); 5772 right(ios); 5773 { 5774 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5775 std::string ex(str, iter.base()); 5776 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5777 assert(ios.width() == 0); 5778 } 5779 ios.width(25); 5780 internal(ios); 5781 { 5782 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5783 std::string ex(str, iter.base()); 5784 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5785 assert(ios.width() == 0); 5786 } 5787 } 5788 ios.imbue(lg); 5789 { 5790 ios.width(0); 5791 { 5792 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5793 std::string ex(str, iter.base()); 5794 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5795 assert(ios.width() == 0); 5796 } 5797 ios.width(25); 5798 left(ios); 5799 { 5800 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5801 std::string ex(str, iter.base()); 5802 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5803 assert(ios.width() == 0); 5804 } 5805 ios.width(25); 5806 right(ios); 5807 { 5808 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5809 std::string ex(str, iter.base()); 5810 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5811 assert(ios.width() == 0); 5812 } 5813 ios.width(25); 5814 internal(ios); 5815 { 5816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5817 std::string ex(str, iter.base()); 5818 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5819 assert(ios.width() == 0); 5820 } 5821 } 5822 } 5823 } 5824 showpos(ios); 5825 { 5826 noshowpoint(ios); 5827 { 5828 ios.imbue(lc); 5829 { 5830 ios.width(0); 5831 { 5832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5833 std::string ex(str, iter.base()); 5834 assert(ex == "-0"); 5835 assert(ios.width() == 0); 5836 } 5837 ios.width(25); 5838 left(ios); 5839 { 5840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5841 std::string ex(str, iter.base()); 5842 assert(ex == "-0***********************"); 5843 assert(ios.width() == 0); 5844 } 5845 ios.width(25); 5846 right(ios); 5847 { 5848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5849 std::string ex(str, iter.base()); 5850 assert(ex == "***********************-0"); 5851 assert(ios.width() == 0); 5852 } 5853 ios.width(25); 5854 internal(ios); 5855 { 5856 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5857 std::string ex(str, iter.base()); 5858 assert(ex == "-***********************0"); 5859 assert(ios.width() == 0); 5860 } 5861 } 5862 ios.imbue(lg); 5863 { 5864 ios.width(0); 5865 { 5866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5867 std::string ex(str, iter.base()); 5868 assert(ex == "-0"); 5869 assert(ios.width() == 0); 5870 } 5871 ios.width(25); 5872 left(ios); 5873 { 5874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5875 std::string ex(str, iter.base()); 5876 assert(ex == "-0***********************"); 5877 assert(ios.width() == 0); 5878 } 5879 ios.width(25); 5880 right(ios); 5881 { 5882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5883 std::string ex(str, iter.base()); 5884 assert(ex == "***********************-0"); 5885 assert(ios.width() == 0); 5886 } 5887 ios.width(25); 5888 internal(ios); 5889 { 5890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5891 std::string ex(str, iter.base()); 5892 assert(ex == "-***********************0"); 5893 assert(ios.width() == 0); 5894 } 5895 } 5896 } 5897 showpoint(ios); 5898 { 5899 ios.imbue(lc); 5900 { 5901 ios.width(0); 5902 { 5903 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5904 std::string ex(str, iter.base()); 5905 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5906 assert(ios.width() == 0); 5907 } 5908 ios.width(25); 5909 left(ios); 5910 { 5911 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5912 std::string ex(str, iter.base()); 5913 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5914 assert(ios.width() == 0); 5915 } 5916 ios.width(25); 5917 right(ios); 5918 { 5919 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5920 std::string ex(str, iter.base()); 5921 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5922 assert(ios.width() == 0); 5923 } 5924 ios.width(25); 5925 internal(ios); 5926 { 5927 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5928 std::string ex(str, iter.base()); 5929 assert(ex == "-0.00000000000000000000000000000000000000000000000000000000000"); 5930 assert(ios.width() == 0); 5931 } 5932 } 5933 ios.imbue(lg); 5934 { 5935 ios.width(0); 5936 { 5937 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5938 std::string ex(str, iter.base()); 5939 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5940 assert(ios.width() == 0); 5941 } 5942 ios.width(25); 5943 left(ios); 5944 { 5945 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5946 std::string ex(str, iter.base()); 5947 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5948 assert(ios.width() == 0); 5949 } 5950 ios.width(25); 5951 right(ios); 5952 { 5953 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5954 std::string ex(str, iter.base()); 5955 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5956 assert(ios.width() == 0); 5957 } 5958 ios.width(25); 5959 internal(ios); 5960 { 5961 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5962 std::string ex(str, iter.base()); 5963 assert(ex == "-0;00000000000000000000000000000000000000000000000000000000000"); 5964 assert(ios.width() == 0); 5965 } 5966 } 5967 } 5968 } 5969 } 5970 } 5971 } 5972 } 5973 } 5974 5975 void test3() 5976 { 5977 char str[200]; 5978 output_iterator<char*> iter; 5979 std::locale lc = std::locale::classic(); 5980 std::locale lg(lc, new my_numpunct); 5981 const my_facet f(1); 5982 { 5983 long double v = 1234567890.125; 5984 std::ios ios(0); 5985 // %g 5986 { 5987 ios.precision(0); 5988 { 5989 nouppercase(ios); 5990 { 5991 noshowpos(ios); 5992 { 5993 noshowpoint(ios); 5994 { 5995 ios.imbue(lc); 5996 { 5997 ios.width(0); 5998 { 5999 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6000 std::string ex(str, iter.base()); 6001 assert(ex == "1e+09"); 6002 assert(ios.width() == 0); 6003 } 6004 ios.width(25); 6005 left(ios); 6006 { 6007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6008 std::string ex(str, iter.base()); 6009 assert(ex == "1e+09********************"); 6010 assert(ios.width() == 0); 6011 } 6012 ios.width(25); 6013 right(ios); 6014 { 6015 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6016 std::string ex(str, iter.base()); 6017 assert(ex == "********************1e+09"); 6018 assert(ios.width() == 0); 6019 } 6020 ios.width(25); 6021 internal(ios); 6022 { 6023 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6024 std::string ex(str, iter.base()); 6025 assert(ex == "********************1e+09"); 6026 assert(ios.width() == 0); 6027 } 6028 } 6029 ios.imbue(lg); 6030 { 6031 ios.width(0); 6032 { 6033 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6034 std::string ex(str, iter.base()); 6035 assert(ex == "1e+09"); 6036 assert(ios.width() == 0); 6037 } 6038 ios.width(25); 6039 left(ios); 6040 { 6041 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6042 std::string ex(str, iter.base()); 6043 assert(ex == "1e+09********************"); 6044 assert(ios.width() == 0); 6045 } 6046 ios.width(25); 6047 right(ios); 6048 { 6049 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6050 std::string ex(str, iter.base()); 6051 assert(ex == "********************1e+09"); 6052 assert(ios.width() == 0); 6053 } 6054 ios.width(25); 6055 internal(ios); 6056 { 6057 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6058 std::string ex(str, iter.base()); 6059 assert(ex == "********************1e+09"); 6060 assert(ios.width() == 0); 6061 } 6062 } 6063 } 6064 showpoint(ios); 6065 { 6066 ios.imbue(lc); 6067 { 6068 ios.width(0); 6069 { 6070 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6071 std::string ex(str, iter.base()); 6072 assert(ex == "1.e+09"); 6073 assert(ios.width() == 0); 6074 } 6075 ios.width(25); 6076 left(ios); 6077 { 6078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6079 std::string ex(str, iter.base()); 6080 assert(ex == "1.e+09*******************"); 6081 assert(ios.width() == 0); 6082 } 6083 ios.width(25); 6084 right(ios); 6085 { 6086 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6087 std::string ex(str, iter.base()); 6088 assert(ex == "*******************1.e+09"); 6089 assert(ios.width() == 0); 6090 } 6091 ios.width(25); 6092 internal(ios); 6093 { 6094 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6095 std::string ex(str, iter.base()); 6096 assert(ex == "*******************1.e+09"); 6097 assert(ios.width() == 0); 6098 } 6099 } 6100 ios.imbue(lg); 6101 { 6102 ios.width(0); 6103 { 6104 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6105 std::string ex(str, iter.base()); 6106 assert(ex == "1;e+09"); 6107 assert(ios.width() == 0); 6108 } 6109 ios.width(25); 6110 left(ios); 6111 { 6112 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6113 std::string ex(str, iter.base()); 6114 assert(ex == "1;e+09*******************"); 6115 assert(ios.width() == 0); 6116 } 6117 ios.width(25); 6118 right(ios); 6119 { 6120 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6121 std::string ex(str, iter.base()); 6122 assert(ex == "*******************1;e+09"); 6123 assert(ios.width() == 0); 6124 } 6125 ios.width(25); 6126 internal(ios); 6127 { 6128 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6129 std::string ex(str, iter.base()); 6130 assert(ex == "*******************1;e+09"); 6131 assert(ios.width() == 0); 6132 } 6133 } 6134 } 6135 } 6136 showpos(ios); 6137 { 6138 noshowpoint(ios); 6139 { 6140 ios.imbue(lc); 6141 { 6142 ios.width(0); 6143 { 6144 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6145 std::string ex(str, iter.base()); 6146 assert(ex == "+1e+09"); 6147 assert(ios.width() == 0); 6148 } 6149 ios.width(25); 6150 left(ios); 6151 { 6152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6153 std::string ex(str, iter.base()); 6154 assert(ex == "+1e+09*******************"); 6155 assert(ios.width() == 0); 6156 } 6157 ios.width(25); 6158 right(ios); 6159 { 6160 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6161 std::string ex(str, iter.base()); 6162 assert(ex == "*******************+1e+09"); 6163 assert(ios.width() == 0); 6164 } 6165 ios.width(25); 6166 internal(ios); 6167 { 6168 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6169 std::string ex(str, iter.base()); 6170 assert(ex == "+*******************1e+09"); 6171 assert(ios.width() == 0); 6172 } 6173 } 6174 ios.imbue(lg); 6175 { 6176 ios.width(0); 6177 { 6178 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6179 std::string ex(str, iter.base()); 6180 assert(ex == "+1e+09"); 6181 assert(ios.width() == 0); 6182 } 6183 ios.width(25); 6184 left(ios); 6185 { 6186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6187 std::string ex(str, iter.base()); 6188 assert(ex == "+1e+09*******************"); 6189 assert(ios.width() == 0); 6190 } 6191 ios.width(25); 6192 right(ios); 6193 { 6194 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6195 std::string ex(str, iter.base()); 6196 assert(ex == "*******************+1e+09"); 6197 assert(ios.width() == 0); 6198 } 6199 ios.width(25); 6200 internal(ios); 6201 { 6202 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6203 std::string ex(str, iter.base()); 6204 assert(ex == "+*******************1e+09"); 6205 assert(ios.width() == 0); 6206 } 6207 } 6208 } 6209 showpoint(ios); 6210 { 6211 ios.imbue(lc); 6212 { 6213 ios.width(0); 6214 { 6215 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6216 std::string ex(str, iter.base()); 6217 assert(ex == "+1.e+09"); 6218 assert(ios.width() == 0); 6219 } 6220 ios.width(25); 6221 left(ios); 6222 { 6223 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6224 std::string ex(str, iter.base()); 6225 assert(ex == "+1.e+09******************"); 6226 assert(ios.width() == 0); 6227 } 6228 ios.width(25); 6229 right(ios); 6230 { 6231 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6232 std::string ex(str, iter.base()); 6233 assert(ex == "******************+1.e+09"); 6234 assert(ios.width() == 0); 6235 } 6236 ios.width(25); 6237 internal(ios); 6238 { 6239 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6240 std::string ex(str, iter.base()); 6241 assert(ex == "+******************1.e+09"); 6242 assert(ios.width() == 0); 6243 } 6244 } 6245 ios.imbue(lg); 6246 { 6247 ios.width(0); 6248 { 6249 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6250 std::string ex(str, iter.base()); 6251 assert(ex == "+1;e+09"); 6252 assert(ios.width() == 0); 6253 } 6254 ios.width(25); 6255 left(ios); 6256 { 6257 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6258 std::string ex(str, iter.base()); 6259 assert(ex == "+1;e+09******************"); 6260 assert(ios.width() == 0); 6261 } 6262 ios.width(25); 6263 right(ios); 6264 { 6265 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6266 std::string ex(str, iter.base()); 6267 assert(ex == "******************+1;e+09"); 6268 assert(ios.width() == 0); 6269 } 6270 ios.width(25); 6271 internal(ios); 6272 { 6273 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6274 std::string ex(str, iter.base()); 6275 assert(ex == "+******************1;e+09"); 6276 assert(ios.width() == 0); 6277 } 6278 } 6279 } 6280 } 6281 } 6282 uppercase(ios); 6283 { 6284 noshowpos(ios); 6285 { 6286 noshowpoint(ios); 6287 { 6288 ios.imbue(lc); 6289 { 6290 ios.width(0); 6291 { 6292 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6293 std::string ex(str, iter.base()); 6294 assert(ex == "1E+09"); 6295 assert(ios.width() == 0); 6296 } 6297 ios.width(25); 6298 left(ios); 6299 { 6300 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6301 std::string ex(str, iter.base()); 6302 assert(ex == "1E+09********************"); 6303 assert(ios.width() == 0); 6304 } 6305 ios.width(25); 6306 right(ios); 6307 { 6308 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6309 std::string ex(str, iter.base()); 6310 assert(ex == "********************1E+09"); 6311 assert(ios.width() == 0); 6312 } 6313 ios.width(25); 6314 internal(ios); 6315 { 6316 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6317 std::string ex(str, iter.base()); 6318 assert(ex == "********************1E+09"); 6319 assert(ios.width() == 0); 6320 } 6321 } 6322 ios.imbue(lg); 6323 { 6324 ios.width(0); 6325 { 6326 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6327 std::string ex(str, iter.base()); 6328 assert(ex == "1E+09"); 6329 assert(ios.width() == 0); 6330 } 6331 ios.width(25); 6332 left(ios); 6333 { 6334 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6335 std::string ex(str, iter.base()); 6336 assert(ex == "1E+09********************"); 6337 assert(ios.width() == 0); 6338 } 6339 ios.width(25); 6340 right(ios); 6341 { 6342 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6343 std::string ex(str, iter.base()); 6344 assert(ex == "********************1E+09"); 6345 assert(ios.width() == 0); 6346 } 6347 ios.width(25); 6348 internal(ios); 6349 { 6350 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6351 std::string ex(str, iter.base()); 6352 assert(ex == "********************1E+09"); 6353 assert(ios.width() == 0); 6354 } 6355 } 6356 } 6357 showpoint(ios); 6358 { 6359 ios.imbue(lc); 6360 { 6361 ios.width(0); 6362 { 6363 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6364 std::string ex(str, iter.base()); 6365 assert(ex == "1.E+09"); 6366 assert(ios.width() == 0); 6367 } 6368 ios.width(25); 6369 left(ios); 6370 { 6371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6372 std::string ex(str, iter.base()); 6373 assert(ex == "1.E+09*******************"); 6374 assert(ios.width() == 0); 6375 } 6376 ios.width(25); 6377 right(ios); 6378 { 6379 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6380 std::string ex(str, iter.base()); 6381 assert(ex == "*******************1.E+09"); 6382 assert(ios.width() == 0); 6383 } 6384 ios.width(25); 6385 internal(ios); 6386 { 6387 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6388 std::string ex(str, iter.base()); 6389 assert(ex == "*******************1.E+09"); 6390 assert(ios.width() == 0); 6391 } 6392 } 6393 ios.imbue(lg); 6394 { 6395 ios.width(0); 6396 { 6397 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6398 std::string ex(str, iter.base()); 6399 assert(ex == "1;E+09"); 6400 assert(ios.width() == 0); 6401 } 6402 ios.width(25); 6403 left(ios); 6404 { 6405 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6406 std::string ex(str, iter.base()); 6407 assert(ex == "1;E+09*******************"); 6408 assert(ios.width() == 0); 6409 } 6410 ios.width(25); 6411 right(ios); 6412 { 6413 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6414 std::string ex(str, iter.base()); 6415 assert(ex == "*******************1;E+09"); 6416 assert(ios.width() == 0); 6417 } 6418 ios.width(25); 6419 internal(ios); 6420 { 6421 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6422 std::string ex(str, iter.base()); 6423 assert(ex == "*******************1;E+09"); 6424 assert(ios.width() == 0); 6425 } 6426 } 6427 } 6428 } 6429 showpos(ios); 6430 { 6431 noshowpoint(ios); 6432 { 6433 ios.imbue(lc); 6434 { 6435 ios.width(0); 6436 { 6437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6438 std::string ex(str, iter.base()); 6439 assert(ex == "+1E+09"); 6440 assert(ios.width() == 0); 6441 } 6442 ios.width(25); 6443 left(ios); 6444 { 6445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6446 std::string ex(str, iter.base()); 6447 assert(ex == "+1E+09*******************"); 6448 assert(ios.width() == 0); 6449 } 6450 ios.width(25); 6451 right(ios); 6452 { 6453 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6454 std::string ex(str, iter.base()); 6455 assert(ex == "*******************+1E+09"); 6456 assert(ios.width() == 0); 6457 } 6458 ios.width(25); 6459 internal(ios); 6460 { 6461 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6462 std::string ex(str, iter.base()); 6463 assert(ex == "+*******************1E+09"); 6464 assert(ios.width() == 0); 6465 } 6466 } 6467 ios.imbue(lg); 6468 { 6469 ios.width(0); 6470 { 6471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6472 std::string ex(str, iter.base()); 6473 assert(ex == "+1E+09"); 6474 assert(ios.width() == 0); 6475 } 6476 ios.width(25); 6477 left(ios); 6478 { 6479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6480 std::string ex(str, iter.base()); 6481 assert(ex == "+1E+09*******************"); 6482 assert(ios.width() == 0); 6483 } 6484 ios.width(25); 6485 right(ios); 6486 { 6487 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6488 std::string ex(str, iter.base()); 6489 assert(ex == "*******************+1E+09"); 6490 assert(ios.width() == 0); 6491 } 6492 ios.width(25); 6493 internal(ios); 6494 { 6495 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6496 std::string ex(str, iter.base()); 6497 assert(ex == "+*******************1E+09"); 6498 assert(ios.width() == 0); 6499 } 6500 } 6501 } 6502 showpoint(ios); 6503 { 6504 ios.imbue(lc); 6505 { 6506 ios.width(0); 6507 { 6508 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6509 std::string ex(str, iter.base()); 6510 assert(ex == "+1.E+09"); 6511 assert(ios.width() == 0); 6512 } 6513 ios.width(25); 6514 left(ios); 6515 { 6516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6517 std::string ex(str, iter.base()); 6518 assert(ex == "+1.E+09******************"); 6519 assert(ios.width() == 0); 6520 } 6521 ios.width(25); 6522 right(ios); 6523 { 6524 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6525 std::string ex(str, iter.base()); 6526 assert(ex == "******************+1.E+09"); 6527 assert(ios.width() == 0); 6528 } 6529 ios.width(25); 6530 internal(ios); 6531 { 6532 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6533 std::string ex(str, iter.base()); 6534 assert(ex == "+******************1.E+09"); 6535 assert(ios.width() == 0); 6536 } 6537 } 6538 ios.imbue(lg); 6539 { 6540 ios.width(0); 6541 { 6542 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6543 std::string ex(str, iter.base()); 6544 assert(ex == "+1;E+09"); 6545 assert(ios.width() == 0); 6546 } 6547 ios.width(25); 6548 left(ios); 6549 { 6550 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6551 std::string ex(str, iter.base()); 6552 assert(ex == "+1;E+09******************"); 6553 assert(ios.width() == 0); 6554 } 6555 ios.width(25); 6556 right(ios); 6557 { 6558 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6559 std::string ex(str, iter.base()); 6560 assert(ex == "******************+1;E+09"); 6561 assert(ios.width() == 0); 6562 } 6563 ios.width(25); 6564 internal(ios); 6565 { 6566 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6567 std::string ex(str, iter.base()); 6568 assert(ex == "+******************1;E+09"); 6569 assert(ios.width() == 0); 6570 } 6571 } 6572 } 6573 } 6574 } 6575 } 6576 ios.precision(1); 6577 { 6578 nouppercase(ios); 6579 { 6580 noshowpos(ios); 6581 { 6582 noshowpoint(ios); 6583 { 6584 ios.imbue(lc); 6585 { 6586 ios.width(0); 6587 { 6588 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6589 std::string ex(str, iter.base()); 6590 assert(ex == "1e+09"); 6591 assert(ios.width() == 0); 6592 } 6593 ios.width(25); 6594 left(ios); 6595 { 6596 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6597 std::string ex(str, iter.base()); 6598 assert(ex == "1e+09********************"); 6599 assert(ios.width() == 0); 6600 } 6601 ios.width(25); 6602 right(ios); 6603 { 6604 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6605 std::string ex(str, iter.base()); 6606 assert(ex == "********************1e+09"); 6607 assert(ios.width() == 0); 6608 } 6609 ios.width(25); 6610 internal(ios); 6611 { 6612 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6613 std::string ex(str, iter.base()); 6614 assert(ex == "********************1e+09"); 6615 assert(ios.width() == 0); 6616 } 6617 } 6618 ios.imbue(lg); 6619 { 6620 ios.width(0); 6621 { 6622 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6623 std::string ex(str, iter.base()); 6624 assert(ex == "1e+09"); 6625 assert(ios.width() == 0); 6626 } 6627 ios.width(25); 6628 left(ios); 6629 { 6630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6631 std::string ex(str, iter.base()); 6632 assert(ex == "1e+09********************"); 6633 assert(ios.width() == 0); 6634 } 6635 ios.width(25); 6636 right(ios); 6637 { 6638 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6639 std::string ex(str, iter.base()); 6640 assert(ex == "********************1e+09"); 6641 assert(ios.width() == 0); 6642 } 6643 ios.width(25); 6644 internal(ios); 6645 { 6646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6647 std::string ex(str, iter.base()); 6648 assert(ex == "********************1e+09"); 6649 assert(ios.width() == 0); 6650 } 6651 } 6652 } 6653 showpoint(ios); 6654 { 6655 ios.imbue(lc); 6656 { 6657 ios.width(0); 6658 { 6659 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6660 std::string ex(str, iter.base()); 6661 assert(ex == "1.e+09"); 6662 assert(ios.width() == 0); 6663 } 6664 ios.width(25); 6665 left(ios); 6666 { 6667 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6668 std::string ex(str, iter.base()); 6669 assert(ex == "1.e+09*******************"); 6670 assert(ios.width() == 0); 6671 } 6672 ios.width(25); 6673 right(ios); 6674 { 6675 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6676 std::string ex(str, iter.base()); 6677 assert(ex == "*******************1.e+09"); 6678 assert(ios.width() == 0); 6679 } 6680 ios.width(25); 6681 internal(ios); 6682 { 6683 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6684 std::string ex(str, iter.base()); 6685 assert(ex == "*******************1.e+09"); 6686 assert(ios.width() == 0); 6687 } 6688 } 6689 ios.imbue(lg); 6690 { 6691 ios.width(0); 6692 { 6693 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6694 std::string ex(str, iter.base()); 6695 assert(ex == "1;e+09"); 6696 assert(ios.width() == 0); 6697 } 6698 ios.width(25); 6699 left(ios); 6700 { 6701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6702 std::string ex(str, iter.base()); 6703 assert(ex == "1;e+09*******************"); 6704 assert(ios.width() == 0); 6705 } 6706 ios.width(25); 6707 right(ios); 6708 { 6709 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6710 std::string ex(str, iter.base()); 6711 assert(ex == "*******************1;e+09"); 6712 assert(ios.width() == 0); 6713 } 6714 ios.width(25); 6715 internal(ios); 6716 { 6717 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6718 std::string ex(str, iter.base()); 6719 assert(ex == "*******************1;e+09"); 6720 assert(ios.width() == 0); 6721 } 6722 } 6723 } 6724 } 6725 showpos(ios); 6726 { 6727 noshowpoint(ios); 6728 { 6729 ios.imbue(lc); 6730 { 6731 ios.width(0); 6732 { 6733 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6734 std::string ex(str, iter.base()); 6735 assert(ex == "+1e+09"); 6736 assert(ios.width() == 0); 6737 } 6738 ios.width(25); 6739 left(ios); 6740 { 6741 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6742 std::string ex(str, iter.base()); 6743 assert(ex == "+1e+09*******************"); 6744 assert(ios.width() == 0); 6745 } 6746 ios.width(25); 6747 right(ios); 6748 { 6749 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6750 std::string ex(str, iter.base()); 6751 assert(ex == "*******************+1e+09"); 6752 assert(ios.width() == 0); 6753 } 6754 ios.width(25); 6755 internal(ios); 6756 { 6757 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6758 std::string ex(str, iter.base()); 6759 assert(ex == "+*******************1e+09"); 6760 assert(ios.width() == 0); 6761 } 6762 } 6763 ios.imbue(lg); 6764 { 6765 ios.width(0); 6766 { 6767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6768 std::string ex(str, iter.base()); 6769 assert(ex == "+1e+09"); 6770 assert(ios.width() == 0); 6771 } 6772 ios.width(25); 6773 left(ios); 6774 { 6775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6776 std::string ex(str, iter.base()); 6777 assert(ex == "+1e+09*******************"); 6778 assert(ios.width() == 0); 6779 } 6780 ios.width(25); 6781 right(ios); 6782 { 6783 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6784 std::string ex(str, iter.base()); 6785 assert(ex == "*******************+1e+09"); 6786 assert(ios.width() == 0); 6787 } 6788 ios.width(25); 6789 internal(ios); 6790 { 6791 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6792 std::string ex(str, iter.base()); 6793 assert(ex == "+*******************1e+09"); 6794 assert(ios.width() == 0); 6795 } 6796 } 6797 } 6798 showpoint(ios); 6799 { 6800 ios.imbue(lc); 6801 { 6802 ios.width(0); 6803 { 6804 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6805 std::string ex(str, iter.base()); 6806 assert(ex == "+1.e+09"); 6807 assert(ios.width() == 0); 6808 } 6809 ios.width(25); 6810 left(ios); 6811 { 6812 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6813 std::string ex(str, iter.base()); 6814 assert(ex == "+1.e+09******************"); 6815 assert(ios.width() == 0); 6816 } 6817 ios.width(25); 6818 right(ios); 6819 { 6820 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6821 std::string ex(str, iter.base()); 6822 assert(ex == "******************+1.e+09"); 6823 assert(ios.width() == 0); 6824 } 6825 ios.width(25); 6826 internal(ios); 6827 { 6828 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6829 std::string ex(str, iter.base()); 6830 assert(ex == "+******************1.e+09"); 6831 assert(ios.width() == 0); 6832 } 6833 } 6834 ios.imbue(lg); 6835 { 6836 ios.width(0); 6837 { 6838 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6839 std::string ex(str, iter.base()); 6840 assert(ex == "+1;e+09"); 6841 assert(ios.width() == 0); 6842 } 6843 ios.width(25); 6844 left(ios); 6845 { 6846 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6847 std::string ex(str, iter.base()); 6848 assert(ex == "+1;e+09******************"); 6849 assert(ios.width() == 0); 6850 } 6851 ios.width(25); 6852 right(ios); 6853 { 6854 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6855 std::string ex(str, iter.base()); 6856 assert(ex == "******************+1;e+09"); 6857 assert(ios.width() == 0); 6858 } 6859 ios.width(25); 6860 internal(ios); 6861 { 6862 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6863 std::string ex(str, iter.base()); 6864 assert(ex == "+******************1;e+09"); 6865 assert(ios.width() == 0); 6866 } 6867 } 6868 } 6869 } 6870 } 6871 uppercase(ios); 6872 { 6873 noshowpos(ios); 6874 { 6875 noshowpoint(ios); 6876 { 6877 ios.imbue(lc); 6878 { 6879 ios.width(0); 6880 { 6881 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6882 std::string ex(str, iter.base()); 6883 assert(ex == "1E+09"); 6884 assert(ios.width() == 0); 6885 } 6886 ios.width(25); 6887 left(ios); 6888 { 6889 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6890 std::string ex(str, iter.base()); 6891 assert(ex == "1E+09********************"); 6892 assert(ios.width() == 0); 6893 } 6894 ios.width(25); 6895 right(ios); 6896 { 6897 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6898 std::string ex(str, iter.base()); 6899 assert(ex == "********************1E+09"); 6900 assert(ios.width() == 0); 6901 } 6902 ios.width(25); 6903 internal(ios); 6904 { 6905 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6906 std::string ex(str, iter.base()); 6907 assert(ex == "********************1E+09"); 6908 assert(ios.width() == 0); 6909 } 6910 } 6911 ios.imbue(lg); 6912 { 6913 ios.width(0); 6914 { 6915 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6916 std::string ex(str, iter.base()); 6917 assert(ex == "1E+09"); 6918 assert(ios.width() == 0); 6919 } 6920 ios.width(25); 6921 left(ios); 6922 { 6923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6924 std::string ex(str, iter.base()); 6925 assert(ex == "1E+09********************"); 6926 assert(ios.width() == 0); 6927 } 6928 ios.width(25); 6929 right(ios); 6930 { 6931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6932 std::string ex(str, iter.base()); 6933 assert(ex == "********************1E+09"); 6934 assert(ios.width() == 0); 6935 } 6936 ios.width(25); 6937 internal(ios); 6938 { 6939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6940 std::string ex(str, iter.base()); 6941 assert(ex == "********************1E+09"); 6942 assert(ios.width() == 0); 6943 } 6944 } 6945 } 6946 showpoint(ios); 6947 { 6948 ios.imbue(lc); 6949 { 6950 ios.width(0); 6951 { 6952 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6953 std::string ex(str, iter.base()); 6954 assert(ex == "1.E+09"); 6955 assert(ios.width() == 0); 6956 } 6957 ios.width(25); 6958 left(ios); 6959 { 6960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6961 std::string ex(str, iter.base()); 6962 assert(ex == "1.E+09*******************"); 6963 assert(ios.width() == 0); 6964 } 6965 ios.width(25); 6966 right(ios); 6967 { 6968 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6969 std::string ex(str, iter.base()); 6970 assert(ex == "*******************1.E+09"); 6971 assert(ios.width() == 0); 6972 } 6973 ios.width(25); 6974 internal(ios); 6975 { 6976 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6977 std::string ex(str, iter.base()); 6978 assert(ex == "*******************1.E+09"); 6979 assert(ios.width() == 0); 6980 } 6981 } 6982 ios.imbue(lg); 6983 { 6984 ios.width(0); 6985 { 6986 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6987 std::string ex(str, iter.base()); 6988 assert(ex == "1;E+09"); 6989 assert(ios.width() == 0); 6990 } 6991 ios.width(25); 6992 left(ios); 6993 { 6994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6995 std::string ex(str, iter.base()); 6996 assert(ex == "1;E+09*******************"); 6997 assert(ios.width() == 0); 6998 } 6999 ios.width(25); 7000 right(ios); 7001 { 7002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7003 std::string ex(str, iter.base()); 7004 assert(ex == "*******************1;E+09"); 7005 assert(ios.width() == 0); 7006 } 7007 ios.width(25); 7008 internal(ios); 7009 { 7010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7011 std::string ex(str, iter.base()); 7012 assert(ex == "*******************1;E+09"); 7013 assert(ios.width() == 0); 7014 } 7015 } 7016 } 7017 } 7018 showpos(ios); 7019 { 7020 noshowpoint(ios); 7021 { 7022 ios.imbue(lc); 7023 { 7024 ios.width(0); 7025 { 7026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7027 std::string ex(str, iter.base()); 7028 assert(ex == "+1E+09"); 7029 assert(ios.width() == 0); 7030 } 7031 ios.width(25); 7032 left(ios); 7033 { 7034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7035 std::string ex(str, iter.base()); 7036 assert(ex == "+1E+09*******************"); 7037 assert(ios.width() == 0); 7038 } 7039 ios.width(25); 7040 right(ios); 7041 { 7042 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7043 std::string ex(str, iter.base()); 7044 assert(ex == "*******************+1E+09"); 7045 assert(ios.width() == 0); 7046 } 7047 ios.width(25); 7048 internal(ios); 7049 { 7050 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7051 std::string ex(str, iter.base()); 7052 assert(ex == "+*******************1E+09"); 7053 assert(ios.width() == 0); 7054 } 7055 } 7056 ios.imbue(lg); 7057 { 7058 ios.width(0); 7059 { 7060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7061 std::string ex(str, iter.base()); 7062 assert(ex == "+1E+09"); 7063 assert(ios.width() == 0); 7064 } 7065 ios.width(25); 7066 left(ios); 7067 { 7068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7069 std::string ex(str, iter.base()); 7070 assert(ex == "+1E+09*******************"); 7071 assert(ios.width() == 0); 7072 } 7073 ios.width(25); 7074 right(ios); 7075 { 7076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7077 std::string ex(str, iter.base()); 7078 assert(ex == "*******************+1E+09"); 7079 assert(ios.width() == 0); 7080 } 7081 ios.width(25); 7082 internal(ios); 7083 { 7084 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7085 std::string ex(str, iter.base()); 7086 assert(ex == "+*******************1E+09"); 7087 assert(ios.width() == 0); 7088 } 7089 } 7090 } 7091 showpoint(ios); 7092 { 7093 ios.imbue(lc); 7094 { 7095 ios.width(0); 7096 { 7097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7098 std::string ex(str, iter.base()); 7099 assert(ex == "+1.E+09"); 7100 assert(ios.width() == 0); 7101 } 7102 ios.width(25); 7103 left(ios); 7104 { 7105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7106 std::string ex(str, iter.base()); 7107 assert(ex == "+1.E+09******************"); 7108 assert(ios.width() == 0); 7109 } 7110 ios.width(25); 7111 right(ios); 7112 { 7113 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7114 std::string ex(str, iter.base()); 7115 assert(ex == "******************+1.E+09"); 7116 assert(ios.width() == 0); 7117 } 7118 ios.width(25); 7119 internal(ios); 7120 { 7121 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7122 std::string ex(str, iter.base()); 7123 assert(ex == "+******************1.E+09"); 7124 assert(ios.width() == 0); 7125 } 7126 } 7127 ios.imbue(lg); 7128 { 7129 ios.width(0); 7130 { 7131 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7132 std::string ex(str, iter.base()); 7133 assert(ex == "+1;E+09"); 7134 assert(ios.width() == 0); 7135 } 7136 ios.width(25); 7137 left(ios); 7138 { 7139 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7140 std::string ex(str, iter.base()); 7141 assert(ex == "+1;E+09******************"); 7142 assert(ios.width() == 0); 7143 } 7144 ios.width(25); 7145 right(ios); 7146 { 7147 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7148 std::string ex(str, iter.base()); 7149 assert(ex == "******************+1;E+09"); 7150 assert(ios.width() == 0); 7151 } 7152 ios.width(25); 7153 internal(ios); 7154 { 7155 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7156 std::string ex(str, iter.base()); 7157 assert(ex == "+******************1;E+09"); 7158 assert(ios.width() == 0); 7159 } 7160 } 7161 } 7162 } 7163 } 7164 } 7165 ios.precision(6); 7166 { 7167 nouppercase(ios); 7168 { 7169 noshowpos(ios); 7170 { 7171 noshowpoint(ios); 7172 { 7173 ios.imbue(lc); 7174 { 7175 ios.width(0); 7176 { 7177 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7178 std::string ex(str, iter.base()); 7179 assert(ex == "1.23457e+09"); 7180 assert(ios.width() == 0); 7181 } 7182 ios.width(25); 7183 left(ios); 7184 { 7185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7186 std::string ex(str, iter.base()); 7187 assert(ex == "1.23457e+09**************"); 7188 assert(ios.width() == 0); 7189 } 7190 ios.width(25); 7191 right(ios); 7192 { 7193 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7194 std::string ex(str, iter.base()); 7195 assert(ex == "**************1.23457e+09"); 7196 assert(ios.width() == 0); 7197 } 7198 ios.width(25); 7199 internal(ios); 7200 { 7201 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7202 std::string ex(str, iter.base()); 7203 assert(ex == "**************1.23457e+09"); 7204 assert(ios.width() == 0); 7205 } 7206 } 7207 ios.imbue(lg); 7208 { 7209 ios.width(0); 7210 { 7211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7212 std::string ex(str, iter.base()); 7213 assert(ex == "1;23457e+09"); 7214 assert(ios.width() == 0); 7215 } 7216 ios.width(25); 7217 left(ios); 7218 { 7219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7220 std::string ex(str, iter.base()); 7221 assert(ex == "1;23457e+09**************"); 7222 assert(ios.width() == 0); 7223 } 7224 ios.width(25); 7225 right(ios); 7226 { 7227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7228 std::string ex(str, iter.base()); 7229 assert(ex == "**************1;23457e+09"); 7230 assert(ios.width() == 0); 7231 } 7232 ios.width(25); 7233 internal(ios); 7234 { 7235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7236 std::string ex(str, iter.base()); 7237 assert(ex == "**************1;23457e+09"); 7238 assert(ios.width() == 0); 7239 } 7240 } 7241 } 7242 showpoint(ios); 7243 { 7244 ios.imbue(lc); 7245 { 7246 ios.width(0); 7247 { 7248 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7249 std::string ex(str, iter.base()); 7250 assert(ex == "1.23457e+09"); 7251 assert(ios.width() == 0); 7252 } 7253 ios.width(25); 7254 left(ios); 7255 { 7256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7257 std::string ex(str, iter.base()); 7258 assert(ex == "1.23457e+09**************"); 7259 assert(ios.width() == 0); 7260 } 7261 ios.width(25); 7262 right(ios); 7263 { 7264 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7265 std::string ex(str, iter.base()); 7266 assert(ex == "**************1.23457e+09"); 7267 assert(ios.width() == 0); 7268 } 7269 ios.width(25); 7270 internal(ios); 7271 { 7272 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7273 std::string ex(str, iter.base()); 7274 assert(ex == "**************1.23457e+09"); 7275 assert(ios.width() == 0); 7276 } 7277 } 7278 ios.imbue(lg); 7279 { 7280 ios.width(0); 7281 { 7282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7283 std::string ex(str, iter.base()); 7284 assert(ex == "1;23457e+09"); 7285 assert(ios.width() == 0); 7286 } 7287 ios.width(25); 7288 left(ios); 7289 { 7290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7291 std::string ex(str, iter.base()); 7292 assert(ex == "1;23457e+09**************"); 7293 assert(ios.width() == 0); 7294 } 7295 ios.width(25); 7296 right(ios); 7297 { 7298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7299 std::string ex(str, iter.base()); 7300 assert(ex == "**************1;23457e+09"); 7301 assert(ios.width() == 0); 7302 } 7303 ios.width(25); 7304 internal(ios); 7305 { 7306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7307 std::string ex(str, iter.base()); 7308 assert(ex == "**************1;23457e+09"); 7309 assert(ios.width() == 0); 7310 } 7311 } 7312 } 7313 } 7314 showpos(ios); 7315 { 7316 noshowpoint(ios); 7317 { 7318 ios.imbue(lc); 7319 { 7320 ios.width(0); 7321 { 7322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7323 std::string ex(str, iter.base()); 7324 assert(ex == "+1.23457e+09"); 7325 assert(ios.width() == 0); 7326 } 7327 ios.width(25); 7328 left(ios); 7329 { 7330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7331 std::string ex(str, iter.base()); 7332 assert(ex == "+1.23457e+09*************"); 7333 assert(ios.width() == 0); 7334 } 7335 ios.width(25); 7336 right(ios); 7337 { 7338 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7339 std::string ex(str, iter.base()); 7340 assert(ex == "*************+1.23457e+09"); 7341 assert(ios.width() == 0); 7342 } 7343 ios.width(25); 7344 internal(ios); 7345 { 7346 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7347 std::string ex(str, iter.base()); 7348 assert(ex == "+*************1.23457e+09"); 7349 assert(ios.width() == 0); 7350 } 7351 } 7352 ios.imbue(lg); 7353 { 7354 ios.width(0); 7355 { 7356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7357 std::string ex(str, iter.base()); 7358 assert(ex == "+1;23457e+09"); 7359 assert(ios.width() == 0); 7360 } 7361 ios.width(25); 7362 left(ios); 7363 { 7364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7365 std::string ex(str, iter.base()); 7366 assert(ex == "+1;23457e+09*************"); 7367 assert(ios.width() == 0); 7368 } 7369 ios.width(25); 7370 right(ios); 7371 { 7372 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7373 std::string ex(str, iter.base()); 7374 assert(ex == "*************+1;23457e+09"); 7375 assert(ios.width() == 0); 7376 } 7377 ios.width(25); 7378 internal(ios); 7379 { 7380 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7381 std::string ex(str, iter.base()); 7382 assert(ex == "+*************1;23457e+09"); 7383 assert(ios.width() == 0); 7384 } 7385 } 7386 } 7387 showpoint(ios); 7388 { 7389 ios.imbue(lc); 7390 { 7391 ios.width(0); 7392 { 7393 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7394 std::string ex(str, iter.base()); 7395 assert(ex == "+1.23457e+09"); 7396 assert(ios.width() == 0); 7397 } 7398 ios.width(25); 7399 left(ios); 7400 { 7401 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7402 std::string ex(str, iter.base()); 7403 assert(ex == "+1.23457e+09*************"); 7404 assert(ios.width() == 0); 7405 } 7406 ios.width(25); 7407 right(ios); 7408 { 7409 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7410 std::string ex(str, iter.base()); 7411 assert(ex == "*************+1.23457e+09"); 7412 assert(ios.width() == 0); 7413 } 7414 ios.width(25); 7415 internal(ios); 7416 { 7417 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7418 std::string ex(str, iter.base()); 7419 assert(ex == "+*************1.23457e+09"); 7420 assert(ios.width() == 0); 7421 } 7422 } 7423 ios.imbue(lg); 7424 { 7425 ios.width(0); 7426 { 7427 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7428 std::string ex(str, iter.base()); 7429 assert(ex == "+1;23457e+09"); 7430 assert(ios.width() == 0); 7431 } 7432 ios.width(25); 7433 left(ios); 7434 { 7435 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7436 std::string ex(str, iter.base()); 7437 assert(ex == "+1;23457e+09*************"); 7438 assert(ios.width() == 0); 7439 } 7440 ios.width(25); 7441 right(ios); 7442 { 7443 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7444 std::string ex(str, iter.base()); 7445 assert(ex == "*************+1;23457e+09"); 7446 assert(ios.width() == 0); 7447 } 7448 ios.width(25); 7449 internal(ios); 7450 { 7451 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7452 std::string ex(str, iter.base()); 7453 assert(ex == "+*************1;23457e+09"); 7454 assert(ios.width() == 0); 7455 } 7456 } 7457 } 7458 } 7459 } 7460 uppercase(ios); 7461 { 7462 noshowpos(ios); 7463 { 7464 noshowpoint(ios); 7465 { 7466 ios.imbue(lc); 7467 { 7468 ios.width(0); 7469 { 7470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7471 std::string ex(str, iter.base()); 7472 assert(ex == "1.23457E+09"); 7473 assert(ios.width() == 0); 7474 } 7475 ios.width(25); 7476 left(ios); 7477 { 7478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7479 std::string ex(str, iter.base()); 7480 assert(ex == "1.23457E+09**************"); 7481 assert(ios.width() == 0); 7482 } 7483 ios.width(25); 7484 right(ios); 7485 { 7486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7487 std::string ex(str, iter.base()); 7488 assert(ex == "**************1.23457E+09"); 7489 assert(ios.width() == 0); 7490 } 7491 ios.width(25); 7492 internal(ios); 7493 { 7494 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7495 std::string ex(str, iter.base()); 7496 assert(ex == "**************1.23457E+09"); 7497 assert(ios.width() == 0); 7498 } 7499 } 7500 ios.imbue(lg); 7501 { 7502 ios.width(0); 7503 { 7504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7505 std::string ex(str, iter.base()); 7506 assert(ex == "1;23457E+09"); 7507 assert(ios.width() == 0); 7508 } 7509 ios.width(25); 7510 left(ios); 7511 { 7512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7513 std::string ex(str, iter.base()); 7514 assert(ex == "1;23457E+09**************"); 7515 assert(ios.width() == 0); 7516 } 7517 ios.width(25); 7518 right(ios); 7519 { 7520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7521 std::string ex(str, iter.base()); 7522 assert(ex == "**************1;23457E+09"); 7523 assert(ios.width() == 0); 7524 } 7525 ios.width(25); 7526 internal(ios); 7527 { 7528 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7529 std::string ex(str, iter.base()); 7530 assert(ex == "**************1;23457E+09"); 7531 assert(ios.width() == 0); 7532 } 7533 } 7534 } 7535 showpoint(ios); 7536 { 7537 ios.imbue(lc); 7538 { 7539 ios.width(0); 7540 { 7541 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7542 std::string ex(str, iter.base()); 7543 assert(ex == "1.23457E+09"); 7544 assert(ios.width() == 0); 7545 } 7546 ios.width(25); 7547 left(ios); 7548 { 7549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7550 std::string ex(str, iter.base()); 7551 assert(ex == "1.23457E+09**************"); 7552 assert(ios.width() == 0); 7553 } 7554 ios.width(25); 7555 right(ios); 7556 { 7557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7558 std::string ex(str, iter.base()); 7559 assert(ex == "**************1.23457E+09"); 7560 assert(ios.width() == 0); 7561 } 7562 ios.width(25); 7563 internal(ios); 7564 { 7565 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7566 std::string ex(str, iter.base()); 7567 assert(ex == "**************1.23457E+09"); 7568 assert(ios.width() == 0); 7569 } 7570 } 7571 ios.imbue(lg); 7572 { 7573 ios.width(0); 7574 { 7575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7576 std::string ex(str, iter.base()); 7577 assert(ex == "1;23457E+09"); 7578 assert(ios.width() == 0); 7579 } 7580 ios.width(25); 7581 left(ios); 7582 { 7583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7584 std::string ex(str, iter.base()); 7585 assert(ex == "1;23457E+09**************"); 7586 assert(ios.width() == 0); 7587 } 7588 ios.width(25); 7589 right(ios); 7590 { 7591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7592 std::string ex(str, iter.base()); 7593 assert(ex == "**************1;23457E+09"); 7594 assert(ios.width() == 0); 7595 } 7596 ios.width(25); 7597 internal(ios); 7598 { 7599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7600 std::string ex(str, iter.base()); 7601 assert(ex == "**************1;23457E+09"); 7602 assert(ios.width() == 0); 7603 } 7604 } 7605 } 7606 } 7607 showpos(ios); 7608 { 7609 noshowpoint(ios); 7610 { 7611 ios.imbue(lc); 7612 { 7613 ios.width(0); 7614 { 7615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7616 std::string ex(str, iter.base()); 7617 assert(ex == "+1.23457E+09"); 7618 assert(ios.width() == 0); 7619 } 7620 ios.width(25); 7621 left(ios); 7622 { 7623 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7624 std::string ex(str, iter.base()); 7625 assert(ex == "+1.23457E+09*************"); 7626 assert(ios.width() == 0); 7627 } 7628 ios.width(25); 7629 right(ios); 7630 { 7631 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7632 std::string ex(str, iter.base()); 7633 assert(ex == "*************+1.23457E+09"); 7634 assert(ios.width() == 0); 7635 } 7636 ios.width(25); 7637 internal(ios); 7638 { 7639 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7640 std::string ex(str, iter.base()); 7641 assert(ex == "+*************1.23457E+09"); 7642 assert(ios.width() == 0); 7643 } 7644 } 7645 ios.imbue(lg); 7646 { 7647 ios.width(0); 7648 { 7649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7650 std::string ex(str, iter.base()); 7651 assert(ex == "+1;23457E+09"); 7652 assert(ios.width() == 0); 7653 } 7654 ios.width(25); 7655 left(ios); 7656 { 7657 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7658 std::string ex(str, iter.base()); 7659 assert(ex == "+1;23457E+09*************"); 7660 assert(ios.width() == 0); 7661 } 7662 ios.width(25); 7663 right(ios); 7664 { 7665 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7666 std::string ex(str, iter.base()); 7667 assert(ex == "*************+1;23457E+09"); 7668 assert(ios.width() == 0); 7669 } 7670 ios.width(25); 7671 internal(ios); 7672 { 7673 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7674 std::string ex(str, iter.base()); 7675 assert(ex == "+*************1;23457E+09"); 7676 assert(ios.width() == 0); 7677 } 7678 } 7679 } 7680 showpoint(ios); 7681 { 7682 ios.imbue(lc); 7683 { 7684 ios.width(0); 7685 { 7686 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7687 std::string ex(str, iter.base()); 7688 assert(ex == "+1.23457E+09"); 7689 assert(ios.width() == 0); 7690 } 7691 ios.width(25); 7692 left(ios); 7693 { 7694 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7695 std::string ex(str, iter.base()); 7696 assert(ex == "+1.23457E+09*************"); 7697 assert(ios.width() == 0); 7698 } 7699 ios.width(25); 7700 right(ios); 7701 { 7702 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7703 std::string ex(str, iter.base()); 7704 assert(ex == "*************+1.23457E+09"); 7705 assert(ios.width() == 0); 7706 } 7707 ios.width(25); 7708 internal(ios); 7709 { 7710 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7711 std::string ex(str, iter.base()); 7712 assert(ex == "+*************1.23457E+09"); 7713 assert(ios.width() == 0); 7714 } 7715 } 7716 ios.imbue(lg); 7717 { 7718 ios.width(0); 7719 { 7720 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7721 std::string ex(str, iter.base()); 7722 assert(ex == "+1;23457E+09"); 7723 assert(ios.width() == 0); 7724 } 7725 ios.width(25); 7726 left(ios); 7727 { 7728 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7729 std::string ex(str, iter.base()); 7730 assert(ex == "+1;23457E+09*************"); 7731 assert(ios.width() == 0); 7732 } 7733 ios.width(25); 7734 right(ios); 7735 { 7736 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7737 std::string ex(str, iter.base()); 7738 assert(ex == "*************+1;23457E+09"); 7739 assert(ios.width() == 0); 7740 } 7741 ios.width(25); 7742 internal(ios); 7743 { 7744 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7745 std::string ex(str, iter.base()); 7746 assert(ex == "+*************1;23457E+09"); 7747 assert(ios.width() == 0); 7748 } 7749 } 7750 } 7751 } 7752 } 7753 } 7754 ios.precision(16); 7755 { 7756 nouppercase(ios); 7757 { 7758 noshowpos(ios); 7759 { 7760 noshowpoint(ios); 7761 { 7762 ios.imbue(lc); 7763 { 7764 ios.width(0); 7765 { 7766 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7767 std::string ex(str, iter.base()); 7768 assert(ex == "1234567890.125"); 7769 assert(ios.width() == 0); 7770 } 7771 ios.width(25); 7772 left(ios); 7773 { 7774 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7775 std::string ex(str, iter.base()); 7776 assert(ex == "1234567890.125***********"); 7777 assert(ios.width() == 0); 7778 } 7779 ios.width(25); 7780 right(ios); 7781 { 7782 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7783 std::string ex(str, iter.base()); 7784 assert(ex == "***********1234567890.125"); 7785 assert(ios.width() == 0); 7786 } 7787 ios.width(25); 7788 internal(ios); 7789 { 7790 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7791 std::string ex(str, iter.base()); 7792 assert(ex == "***********1234567890.125"); 7793 assert(ios.width() == 0); 7794 } 7795 } 7796 ios.imbue(lg); 7797 { 7798 ios.width(0); 7799 { 7800 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7801 std::string ex(str, iter.base()); 7802 assert(ex == "1_234_567_89_0;125"); 7803 assert(ios.width() == 0); 7804 } 7805 ios.width(25); 7806 left(ios); 7807 { 7808 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7809 std::string ex(str, iter.base()); 7810 assert(ex == "1_234_567_89_0;125*******"); 7811 assert(ios.width() == 0); 7812 } 7813 ios.width(25); 7814 right(ios); 7815 { 7816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7817 std::string ex(str, iter.base()); 7818 assert(ex == "*******1_234_567_89_0;125"); 7819 assert(ios.width() == 0); 7820 } 7821 ios.width(25); 7822 internal(ios); 7823 { 7824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7825 std::string ex(str, iter.base()); 7826 assert(ex == "*******1_234_567_89_0;125"); 7827 assert(ios.width() == 0); 7828 } 7829 } 7830 } 7831 showpoint(ios); 7832 { 7833 ios.imbue(lc); 7834 { 7835 ios.width(0); 7836 { 7837 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7838 std::string ex(str, iter.base()); 7839 assert(ex == "1234567890.125000"); 7840 assert(ios.width() == 0); 7841 } 7842 ios.width(25); 7843 left(ios); 7844 { 7845 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7846 std::string ex(str, iter.base()); 7847 assert(ex == "1234567890.125000********"); 7848 assert(ios.width() == 0); 7849 } 7850 ios.width(25); 7851 right(ios); 7852 { 7853 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7854 std::string ex(str, iter.base()); 7855 assert(ex == "********1234567890.125000"); 7856 assert(ios.width() == 0); 7857 } 7858 ios.width(25); 7859 internal(ios); 7860 { 7861 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7862 std::string ex(str, iter.base()); 7863 assert(ex == "********1234567890.125000"); 7864 assert(ios.width() == 0); 7865 } 7866 } 7867 ios.imbue(lg); 7868 { 7869 ios.width(0); 7870 { 7871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7872 std::string ex(str, iter.base()); 7873 assert(ex == "1_234_567_89_0;125000"); 7874 assert(ios.width() == 0); 7875 } 7876 ios.width(25); 7877 left(ios); 7878 { 7879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7880 std::string ex(str, iter.base()); 7881 assert(ex == "1_234_567_89_0;125000****"); 7882 assert(ios.width() == 0); 7883 } 7884 ios.width(25); 7885 right(ios); 7886 { 7887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7888 std::string ex(str, iter.base()); 7889 assert(ex == "****1_234_567_89_0;125000"); 7890 assert(ios.width() == 0); 7891 } 7892 ios.width(25); 7893 internal(ios); 7894 { 7895 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7896 std::string ex(str, iter.base()); 7897 assert(ex == "****1_234_567_89_0;125000"); 7898 assert(ios.width() == 0); 7899 } 7900 } 7901 } 7902 } 7903 showpos(ios); 7904 { 7905 noshowpoint(ios); 7906 { 7907 ios.imbue(lc); 7908 { 7909 ios.width(0); 7910 { 7911 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7912 std::string ex(str, iter.base()); 7913 assert(ex == "+1234567890.125"); 7914 assert(ios.width() == 0); 7915 } 7916 ios.width(25); 7917 left(ios); 7918 { 7919 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7920 std::string ex(str, iter.base()); 7921 assert(ex == "+1234567890.125**********"); 7922 assert(ios.width() == 0); 7923 } 7924 ios.width(25); 7925 right(ios); 7926 { 7927 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7928 std::string ex(str, iter.base()); 7929 assert(ex == "**********+1234567890.125"); 7930 assert(ios.width() == 0); 7931 } 7932 ios.width(25); 7933 internal(ios); 7934 { 7935 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7936 std::string ex(str, iter.base()); 7937 assert(ex == "+**********1234567890.125"); 7938 assert(ios.width() == 0); 7939 } 7940 } 7941 ios.imbue(lg); 7942 { 7943 ios.width(0); 7944 { 7945 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7946 std::string ex(str, iter.base()); 7947 assert(ex == "+1_234_567_89_0;125"); 7948 assert(ios.width() == 0); 7949 } 7950 ios.width(25); 7951 left(ios); 7952 { 7953 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7954 std::string ex(str, iter.base()); 7955 assert(ex == "+1_234_567_89_0;125******"); 7956 assert(ios.width() == 0); 7957 } 7958 ios.width(25); 7959 right(ios); 7960 { 7961 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7962 std::string ex(str, iter.base()); 7963 assert(ex == "******+1_234_567_89_0;125"); 7964 assert(ios.width() == 0); 7965 } 7966 ios.width(25); 7967 internal(ios); 7968 { 7969 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7970 std::string ex(str, iter.base()); 7971 assert(ex == "+******1_234_567_89_0;125"); 7972 assert(ios.width() == 0); 7973 } 7974 } 7975 } 7976 showpoint(ios); 7977 { 7978 ios.imbue(lc); 7979 { 7980 ios.width(0); 7981 { 7982 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7983 std::string ex(str, iter.base()); 7984 assert(ex == "+1234567890.125000"); 7985 assert(ios.width() == 0); 7986 } 7987 ios.width(25); 7988 left(ios); 7989 { 7990 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7991 std::string ex(str, iter.base()); 7992 assert(ex == "+1234567890.125000*******"); 7993 assert(ios.width() == 0); 7994 } 7995 ios.width(25); 7996 right(ios); 7997 { 7998 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7999 std::string ex(str, iter.base()); 8000 assert(ex == "*******+1234567890.125000"); 8001 assert(ios.width() == 0); 8002 } 8003 ios.width(25); 8004 internal(ios); 8005 { 8006 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8007 std::string ex(str, iter.base()); 8008 assert(ex == "+*******1234567890.125000"); 8009 assert(ios.width() == 0); 8010 } 8011 } 8012 ios.imbue(lg); 8013 { 8014 ios.width(0); 8015 { 8016 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8017 std::string ex(str, iter.base()); 8018 assert(ex == "+1_234_567_89_0;125000"); 8019 assert(ios.width() == 0); 8020 } 8021 ios.width(25); 8022 left(ios); 8023 { 8024 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8025 std::string ex(str, iter.base()); 8026 assert(ex == "+1_234_567_89_0;125000***"); 8027 assert(ios.width() == 0); 8028 } 8029 ios.width(25); 8030 right(ios); 8031 { 8032 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8033 std::string ex(str, iter.base()); 8034 assert(ex == "***+1_234_567_89_0;125000"); 8035 assert(ios.width() == 0); 8036 } 8037 ios.width(25); 8038 internal(ios); 8039 { 8040 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8041 std::string ex(str, iter.base()); 8042 assert(ex == "+***1_234_567_89_0;125000"); 8043 assert(ios.width() == 0); 8044 } 8045 } 8046 } 8047 } 8048 } 8049 uppercase(ios); 8050 { 8051 noshowpos(ios); 8052 { 8053 noshowpoint(ios); 8054 { 8055 ios.imbue(lc); 8056 { 8057 ios.width(0); 8058 { 8059 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8060 std::string ex(str, iter.base()); 8061 assert(ex == "1234567890.125"); 8062 assert(ios.width() == 0); 8063 } 8064 ios.width(25); 8065 left(ios); 8066 { 8067 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8068 std::string ex(str, iter.base()); 8069 assert(ex == "1234567890.125***********"); 8070 assert(ios.width() == 0); 8071 } 8072 ios.width(25); 8073 right(ios); 8074 { 8075 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8076 std::string ex(str, iter.base()); 8077 assert(ex == "***********1234567890.125"); 8078 assert(ios.width() == 0); 8079 } 8080 ios.width(25); 8081 internal(ios); 8082 { 8083 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8084 std::string ex(str, iter.base()); 8085 assert(ex == "***********1234567890.125"); 8086 assert(ios.width() == 0); 8087 } 8088 } 8089 ios.imbue(lg); 8090 { 8091 ios.width(0); 8092 { 8093 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8094 std::string ex(str, iter.base()); 8095 assert(ex == "1_234_567_89_0;125"); 8096 assert(ios.width() == 0); 8097 } 8098 ios.width(25); 8099 left(ios); 8100 { 8101 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8102 std::string ex(str, iter.base()); 8103 assert(ex == "1_234_567_89_0;125*******"); 8104 assert(ios.width() == 0); 8105 } 8106 ios.width(25); 8107 right(ios); 8108 { 8109 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8110 std::string ex(str, iter.base()); 8111 assert(ex == "*******1_234_567_89_0;125"); 8112 assert(ios.width() == 0); 8113 } 8114 ios.width(25); 8115 internal(ios); 8116 { 8117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8118 std::string ex(str, iter.base()); 8119 assert(ex == "*******1_234_567_89_0;125"); 8120 assert(ios.width() == 0); 8121 } 8122 } 8123 } 8124 showpoint(ios); 8125 { 8126 ios.imbue(lc); 8127 { 8128 ios.width(0); 8129 { 8130 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8131 std::string ex(str, iter.base()); 8132 assert(ex == "1234567890.125000"); 8133 assert(ios.width() == 0); 8134 } 8135 ios.width(25); 8136 left(ios); 8137 { 8138 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8139 std::string ex(str, iter.base()); 8140 assert(ex == "1234567890.125000********"); 8141 assert(ios.width() == 0); 8142 } 8143 ios.width(25); 8144 right(ios); 8145 { 8146 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8147 std::string ex(str, iter.base()); 8148 assert(ex == "********1234567890.125000"); 8149 assert(ios.width() == 0); 8150 } 8151 ios.width(25); 8152 internal(ios); 8153 { 8154 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8155 std::string ex(str, iter.base()); 8156 assert(ex == "********1234567890.125000"); 8157 assert(ios.width() == 0); 8158 } 8159 } 8160 ios.imbue(lg); 8161 { 8162 ios.width(0); 8163 { 8164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8165 std::string ex(str, iter.base()); 8166 assert(ex == "1_234_567_89_0;125000"); 8167 assert(ios.width() == 0); 8168 } 8169 ios.width(25); 8170 left(ios); 8171 { 8172 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8173 std::string ex(str, iter.base()); 8174 assert(ex == "1_234_567_89_0;125000****"); 8175 assert(ios.width() == 0); 8176 } 8177 ios.width(25); 8178 right(ios); 8179 { 8180 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8181 std::string ex(str, iter.base()); 8182 assert(ex == "****1_234_567_89_0;125000"); 8183 assert(ios.width() == 0); 8184 } 8185 ios.width(25); 8186 internal(ios); 8187 { 8188 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8189 std::string ex(str, iter.base()); 8190 assert(ex == "****1_234_567_89_0;125000"); 8191 assert(ios.width() == 0); 8192 } 8193 } 8194 } 8195 } 8196 showpos(ios); 8197 { 8198 noshowpoint(ios); 8199 { 8200 ios.imbue(lc); 8201 { 8202 ios.width(0); 8203 { 8204 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8205 std::string ex(str, iter.base()); 8206 assert(ex == "+1234567890.125"); 8207 assert(ios.width() == 0); 8208 } 8209 ios.width(25); 8210 left(ios); 8211 { 8212 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8213 std::string ex(str, iter.base()); 8214 assert(ex == "+1234567890.125**********"); 8215 assert(ios.width() == 0); 8216 } 8217 ios.width(25); 8218 right(ios); 8219 { 8220 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8221 std::string ex(str, iter.base()); 8222 assert(ex == "**********+1234567890.125"); 8223 assert(ios.width() == 0); 8224 } 8225 ios.width(25); 8226 internal(ios); 8227 { 8228 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8229 std::string ex(str, iter.base()); 8230 assert(ex == "+**********1234567890.125"); 8231 assert(ios.width() == 0); 8232 } 8233 } 8234 ios.imbue(lg); 8235 { 8236 ios.width(0); 8237 { 8238 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8239 std::string ex(str, iter.base()); 8240 assert(ex == "+1_234_567_89_0;125"); 8241 assert(ios.width() == 0); 8242 } 8243 ios.width(25); 8244 left(ios); 8245 { 8246 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8247 std::string ex(str, iter.base()); 8248 assert(ex == "+1_234_567_89_0;125******"); 8249 assert(ios.width() == 0); 8250 } 8251 ios.width(25); 8252 right(ios); 8253 { 8254 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8255 std::string ex(str, iter.base()); 8256 assert(ex == "******+1_234_567_89_0;125"); 8257 assert(ios.width() == 0); 8258 } 8259 ios.width(25); 8260 internal(ios); 8261 { 8262 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8263 std::string ex(str, iter.base()); 8264 assert(ex == "+******1_234_567_89_0;125"); 8265 assert(ios.width() == 0); 8266 } 8267 } 8268 } 8269 showpoint(ios); 8270 { 8271 ios.imbue(lc); 8272 { 8273 ios.width(0); 8274 { 8275 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8276 std::string ex(str, iter.base()); 8277 assert(ex == "+1234567890.125000"); 8278 assert(ios.width() == 0); 8279 } 8280 ios.width(25); 8281 left(ios); 8282 { 8283 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8284 std::string ex(str, iter.base()); 8285 assert(ex == "+1234567890.125000*******"); 8286 assert(ios.width() == 0); 8287 } 8288 ios.width(25); 8289 right(ios); 8290 { 8291 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8292 std::string ex(str, iter.base()); 8293 assert(ex == "*******+1234567890.125000"); 8294 assert(ios.width() == 0); 8295 } 8296 ios.width(25); 8297 internal(ios); 8298 { 8299 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8300 std::string ex(str, iter.base()); 8301 assert(ex == "+*******1234567890.125000"); 8302 assert(ios.width() == 0); 8303 } 8304 } 8305 ios.imbue(lg); 8306 { 8307 ios.width(0); 8308 { 8309 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8310 std::string ex(str, iter.base()); 8311 assert(ex == "+1_234_567_89_0;125000"); 8312 assert(ios.width() == 0); 8313 } 8314 ios.width(25); 8315 left(ios); 8316 { 8317 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8318 std::string ex(str, iter.base()); 8319 assert(ex == "+1_234_567_89_0;125000***"); 8320 assert(ios.width() == 0); 8321 } 8322 ios.width(25); 8323 right(ios); 8324 { 8325 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8326 std::string ex(str, iter.base()); 8327 assert(ex == "***+1_234_567_89_0;125000"); 8328 assert(ios.width() == 0); 8329 } 8330 ios.width(25); 8331 internal(ios); 8332 { 8333 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8334 std::string ex(str, iter.base()); 8335 assert(ex == "+***1_234_567_89_0;125000"); 8336 assert(ios.width() == 0); 8337 } 8338 } 8339 } 8340 } 8341 } 8342 } 8343 ios.precision(60); 8344 { 8345 nouppercase(ios); 8346 { 8347 noshowpos(ios); 8348 { 8349 noshowpoint(ios); 8350 { 8351 ios.imbue(lc); 8352 { 8353 ios.width(0); 8354 { 8355 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8356 std::string ex(str, iter.base()); 8357 assert(ex == "1234567890.125"); 8358 assert(ios.width() == 0); 8359 } 8360 ios.width(25); 8361 left(ios); 8362 { 8363 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8364 std::string ex(str, iter.base()); 8365 assert(ex == "1234567890.125***********"); 8366 assert(ios.width() == 0); 8367 } 8368 ios.width(25); 8369 right(ios); 8370 { 8371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8372 std::string ex(str, iter.base()); 8373 assert(ex == "***********1234567890.125"); 8374 assert(ios.width() == 0); 8375 } 8376 ios.width(25); 8377 internal(ios); 8378 { 8379 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8380 std::string ex(str, iter.base()); 8381 assert(ex == "***********1234567890.125"); 8382 assert(ios.width() == 0); 8383 } 8384 } 8385 ios.imbue(lg); 8386 { 8387 ios.width(0); 8388 { 8389 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8390 std::string ex(str, iter.base()); 8391 assert(ex == "1_234_567_89_0;125"); 8392 assert(ios.width() == 0); 8393 } 8394 ios.width(25); 8395 left(ios); 8396 { 8397 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8398 std::string ex(str, iter.base()); 8399 assert(ex == "1_234_567_89_0;125*******"); 8400 assert(ios.width() == 0); 8401 } 8402 ios.width(25); 8403 right(ios); 8404 { 8405 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8406 std::string ex(str, iter.base()); 8407 assert(ex == "*******1_234_567_89_0;125"); 8408 assert(ios.width() == 0); 8409 } 8410 ios.width(25); 8411 internal(ios); 8412 { 8413 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8414 std::string ex(str, iter.base()); 8415 assert(ex == "*******1_234_567_89_0;125"); 8416 assert(ios.width() == 0); 8417 } 8418 } 8419 } 8420 showpoint(ios); 8421 { 8422 ios.imbue(lc); 8423 { 8424 ios.width(0); 8425 { 8426 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8427 std::string ex(str, iter.base()); 8428 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8429 assert(ios.width() == 0); 8430 } 8431 ios.width(25); 8432 left(ios); 8433 { 8434 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8435 std::string ex(str, iter.base()); 8436 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8437 assert(ios.width() == 0); 8438 } 8439 ios.width(25); 8440 right(ios); 8441 { 8442 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8443 std::string ex(str, iter.base()); 8444 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8445 assert(ios.width() == 0); 8446 } 8447 ios.width(25); 8448 internal(ios); 8449 { 8450 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8451 std::string ex(str, iter.base()); 8452 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8453 assert(ios.width() == 0); 8454 } 8455 } 8456 ios.imbue(lg); 8457 { 8458 ios.width(0); 8459 { 8460 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8461 std::string ex(str, iter.base()); 8462 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8463 assert(ios.width() == 0); 8464 } 8465 ios.width(25); 8466 left(ios); 8467 { 8468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8469 std::string ex(str, iter.base()); 8470 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8471 assert(ios.width() == 0); 8472 } 8473 ios.width(25); 8474 right(ios); 8475 { 8476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8477 std::string ex(str, iter.base()); 8478 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8479 assert(ios.width() == 0); 8480 } 8481 ios.width(25); 8482 internal(ios); 8483 { 8484 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8485 std::string ex(str, iter.base()); 8486 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8487 assert(ios.width() == 0); 8488 } 8489 } 8490 } 8491 } 8492 showpos(ios); 8493 { 8494 noshowpoint(ios); 8495 { 8496 ios.imbue(lc); 8497 { 8498 ios.width(0); 8499 { 8500 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8501 std::string ex(str, iter.base()); 8502 assert(ex == "+1234567890.125"); 8503 assert(ios.width() == 0); 8504 } 8505 ios.width(25); 8506 left(ios); 8507 { 8508 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8509 std::string ex(str, iter.base()); 8510 assert(ex == "+1234567890.125**********"); 8511 assert(ios.width() == 0); 8512 } 8513 ios.width(25); 8514 right(ios); 8515 { 8516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8517 std::string ex(str, iter.base()); 8518 assert(ex == "**********+1234567890.125"); 8519 assert(ios.width() == 0); 8520 } 8521 ios.width(25); 8522 internal(ios); 8523 { 8524 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8525 std::string ex(str, iter.base()); 8526 assert(ex == "+**********1234567890.125"); 8527 assert(ios.width() == 0); 8528 } 8529 } 8530 ios.imbue(lg); 8531 { 8532 ios.width(0); 8533 { 8534 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8535 std::string ex(str, iter.base()); 8536 assert(ex == "+1_234_567_89_0;125"); 8537 assert(ios.width() == 0); 8538 } 8539 ios.width(25); 8540 left(ios); 8541 { 8542 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8543 std::string ex(str, iter.base()); 8544 assert(ex == "+1_234_567_89_0;125******"); 8545 assert(ios.width() == 0); 8546 } 8547 ios.width(25); 8548 right(ios); 8549 { 8550 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8551 std::string ex(str, iter.base()); 8552 assert(ex == "******+1_234_567_89_0;125"); 8553 assert(ios.width() == 0); 8554 } 8555 ios.width(25); 8556 internal(ios); 8557 { 8558 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8559 std::string ex(str, iter.base()); 8560 assert(ex == "+******1_234_567_89_0;125"); 8561 assert(ios.width() == 0); 8562 } 8563 } 8564 } 8565 showpoint(ios); 8566 { 8567 ios.imbue(lc); 8568 { 8569 ios.width(0); 8570 { 8571 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8572 std::string ex(str, iter.base()); 8573 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8574 assert(ios.width() == 0); 8575 } 8576 ios.width(25); 8577 left(ios); 8578 { 8579 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8580 std::string ex(str, iter.base()); 8581 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8582 assert(ios.width() == 0); 8583 } 8584 ios.width(25); 8585 right(ios); 8586 { 8587 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8588 std::string ex(str, iter.base()); 8589 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8590 assert(ios.width() == 0); 8591 } 8592 ios.width(25); 8593 internal(ios); 8594 { 8595 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8596 std::string ex(str, iter.base()); 8597 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8598 assert(ios.width() == 0); 8599 } 8600 } 8601 ios.imbue(lg); 8602 { 8603 ios.width(0); 8604 { 8605 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8606 std::string ex(str, iter.base()); 8607 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8608 assert(ios.width() == 0); 8609 } 8610 ios.width(25); 8611 left(ios); 8612 { 8613 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8614 std::string ex(str, iter.base()); 8615 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8616 assert(ios.width() == 0); 8617 } 8618 ios.width(25); 8619 right(ios); 8620 { 8621 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8622 std::string ex(str, iter.base()); 8623 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8624 assert(ios.width() == 0); 8625 } 8626 ios.width(25); 8627 internal(ios); 8628 { 8629 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8630 std::string ex(str, iter.base()); 8631 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8632 assert(ios.width() == 0); 8633 } 8634 } 8635 } 8636 } 8637 } 8638 uppercase(ios); 8639 { 8640 noshowpos(ios); 8641 { 8642 noshowpoint(ios); 8643 { 8644 ios.imbue(lc); 8645 { 8646 ios.width(0); 8647 { 8648 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8649 std::string ex(str, iter.base()); 8650 assert(ex == "1234567890.125"); 8651 assert(ios.width() == 0); 8652 } 8653 ios.width(25); 8654 left(ios); 8655 { 8656 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8657 std::string ex(str, iter.base()); 8658 assert(ex == "1234567890.125***********"); 8659 assert(ios.width() == 0); 8660 } 8661 ios.width(25); 8662 right(ios); 8663 { 8664 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8665 std::string ex(str, iter.base()); 8666 assert(ex == "***********1234567890.125"); 8667 assert(ios.width() == 0); 8668 } 8669 ios.width(25); 8670 internal(ios); 8671 { 8672 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8673 std::string ex(str, iter.base()); 8674 assert(ex == "***********1234567890.125"); 8675 assert(ios.width() == 0); 8676 } 8677 } 8678 ios.imbue(lg); 8679 { 8680 ios.width(0); 8681 { 8682 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8683 std::string ex(str, iter.base()); 8684 assert(ex == "1_234_567_89_0;125"); 8685 assert(ios.width() == 0); 8686 } 8687 ios.width(25); 8688 left(ios); 8689 { 8690 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8691 std::string ex(str, iter.base()); 8692 assert(ex == "1_234_567_89_0;125*******"); 8693 assert(ios.width() == 0); 8694 } 8695 ios.width(25); 8696 right(ios); 8697 { 8698 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8699 std::string ex(str, iter.base()); 8700 assert(ex == "*******1_234_567_89_0;125"); 8701 assert(ios.width() == 0); 8702 } 8703 ios.width(25); 8704 internal(ios); 8705 { 8706 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8707 std::string ex(str, iter.base()); 8708 assert(ex == "*******1_234_567_89_0;125"); 8709 assert(ios.width() == 0); 8710 } 8711 } 8712 } 8713 showpoint(ios); 8714 { 8715 ios.imbue(lc); 8716 { 8717 ios.width(0); 8718 { 8719 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8720 std::string ex(str, iter.base()); 8721 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8722 assert(ios.width() == 0); 8723 } 8724 ios.width(25); 8725 left(ios); 8726 { 8727 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8728 std::string ex(str, iter.base()); 8729 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8730 assert(ios.width() == 0); 8731 } 8732 ios.width(25); 8733 right(ios); 8734 { 8735 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8736 std::string ex(str, iter.base()); 8737 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8738 assert(ios.width() == 0); 8739 } 8740 ios.width(25); 8741 internal(ios); 8742 { 8743 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8744 std::string ex(str, iter.base()); 8745 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 8746 assert(ios.width() == 0); 8747 } 8748 } 8749 ios.imbue(lg); 8750 { 8751 ios.width(0); 8752 { 8753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8754 std::string ex(str, iter.base()); 8755 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8756 assert(ios.width() == 0); 8757 } 8758 ios.width(25); 8759 left(ios); 8760 { 8761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8762 std::string ex(str, iter.base()); 8763 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8764 assert(ios.width() == 0); 8765 } 8766 ios.width(25); 8767 right(ios); 8768 { 8769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8770 std::string ex(str, iter.base()); 8771 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8772 assert(ios.width() == 0); 8773 } 8774 ios.width(25); 8775 internal(ios); 8776 { 8777 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8778 std::string ex(str, iter.base()); 8779 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8780 assert(ios.width() == 0); 8781 } 8782 } 8783 } 8784 } 8785 showpos(ios); 8786 { 8787 noshowpoint(ios); 8788 { 8789 ios.imbue(lc); 8790 { 8791 ios.width(0); 8792 { 8793 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8794 std::string ex(str, iter.base()); 8795 assert(ex == "+1234567890.125"); 8796 assert(ios.width() == 0); 8797 } 8798 ios.width(25); 8799 left(ios); 8800 { 8801 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8802 std::string ex(str, iter.base()); 8803 assert(ex == "+1234567890.125**********"); 8804 assert(ios.width() == 0); 8805 } 8806 ios.width(25); 8807 right(ios); 8808 { 8809 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8810 std::string ex(str, iter.base()); 8811 assert(ex == "**********+1234567890.125"); 8812 assert(ios.width() == 0); 8813 } 8814 ios.width(25); 8815 internal(ios); 8816 { 8817 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8818 std::string ex(str, iter.base()); 8819 assert(ex == "+**********1234567890.125"); 8820 assert(ios.width() == 0); 8821 } 8822 } 8823 ios.imbue(lg); 8824 { 8825 ios.width(0); 8826 { 8827 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8828 std::string ex(str, iter.base()); 8829 assert(ex == "+1_234_567_89_0;125"); 8830 assert(ios.width() == 0); 8831 } 8832 ios.width(25); 8833 left(ios); 8834 { 8835 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8836 std::string ex(str, iter.base()); 8837 assert(ex == "+1_234_567_89_0;125******"); 8838 assert(ios.width() == 0); 8839 } 8840 ios.width(25); 8841 right(ios); 8842 { 8843 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8844 std::string ex(str, iter.base()); 8845 assert(ex == "******+1_234_567_89_0;125"); 8846 assert(ios.width() == 0); 8847 } 8848 ios.width(25); 8849 internal(ios); 8850 { 8851 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8852 std::string ex(str, iter.base()); 8853 assert(ex == "+******1_234_567_89_0;125"); 8854 assert(ios.width() == 0); 8855 } 8856 } 8857 } 8858 showpoint(ios); 8859 { 8860 ios.imbue(lc); 8861 { 8862 ios.width(0); 8863 { 8864 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8865 std::string ex(str, iter.base()); 8866 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8867 assert(ios.width() == 0); 8868 } 8869 ios.width(25); 8870 left(ios); 8871 { 8872 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8873 std::string ex(str, iter.base()); 8874 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8875 assert(ios.width() == 0); 8876 } 8877 ios.width(25); 8878 right(ios); 8879 { 8880 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8881 std::string ex(str, iter.base()); 8882 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8883 assert(ios.width() == 0); 8884 } 8885 ios.width(25); 8886 internal(ios); 8887 { 8888 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8889 std::string ex(str, iter.base()); 8890 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 8891 assert(ios.width() == 0); 8892 } 8893 } 8894 ios.imbue(lg); 8895 { 8896 ios.width(0); 8897 { 8898 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8899 std::string ex(str, iter.base()); 8900 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8901 assert(ios.width() == 0); 8902 } 8903 ios.width(25); 8904 left(ios); 8905 { 8906 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8907 std::string ex(str, iter.base()); 8908 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8909 assert(ios.width() == 0); 8910 } 8911 ios.width(25); 8912 right(ios); 8913 { 8914 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8915 std::string ex(str, iter.base()); 8916 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8917 assert(ios.width() == 0); 8918 } 8919 ios.width(25); 8920 internal(ios); 8921 { 8922 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8923 std::string ex(str, iter.base()); 8924 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 8925 assert(ios.width() == 0); 8926 } 8927 } 8928 } 8929 } 8930 } 8931 } 8932 } 8933 } 8934 } 8935 8936 void test4() 8937 { 8938 char str[200]; 8939 output_iterator<char*> iter; 8940 std::locale lc = std::locale::classic(); 8941 std::locale lg(lc, new my_numpunct); 8942 const my_facet f(1); 8943 { 8944 long double v = -INFINITY; 8945 std::ios ios(0); 8946 // %g 8947 { 8948 ios.precision(0); 8949 { 8950 nouppercase(ios); 8951 { 8952 noshowpos(ios); 8953 { 8954 noshowpoint(ios); 8955 { 8956 ios.imbue(lc); 8957 { 8958 ios.width(0); 8959 { 8960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8961 std::string ex(str, iter.base()); 8962 assert(ex == "-inf"); 8963 assert(ios.width() == 0); 8964 } 8965 ios.width(25); 8966 left(ios); 8967 { 8968 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8969 std::string ex(str, iter.base()); 8970 assert(ex == "-inf*********************"); 8971 assert(ios.width() == 0); 8972 } 8973 ios.width(25); 8974 right(ios); 8975 { 8976 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8977 std::string ex(str, iter.base()); 8978 assert(ex == "*********************-inf"); 8979 assert(ios.width() == 0); 8980 } 8981 ios.width(25); 8982 internal(ios); 8983 { 8984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8985 std::string ex(str, iter.base()); 8986 assert(ex == "-*********************inf"); 8987 assert(ios.width() == 0); 8988 } 8989 } 8990 ios.imbue(lg); 8991 { 8992 ios.width(0); 8993 { 8994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8995 std::string ex(str, iter.base()); 8996 assert(ex == "-inf"); 8997 assert(ios.width() == 0); 8998 } 8999 ios.width(25); 9000 left(ios); 9001 { 9002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9003 std::string ex(str, iter.base()); 9004 assert(ex == "-inf*********************"); 9005 assert(ios.width() == 0); 9006 } 9007 ios.width(25); 9008 right(ios); 9009 { 9010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9011 std::string ex(str, iter.base()); 9012 assert(ex == "*********************-inf"); 9013 assert(ios.width() == 0); 9014 } 9015 ios.width(25); 9016 internal(ios); 9017 { 9018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9019 std::string ex(str, iter.base()); 9020 assert(ex == "-*********************inf"); 9021 assert(ios.width() == 0); 9022 } 9023 } 9024 } 9025 showpoint(ios); 9026 { 9027 ios.imbue(lc); 9028 { 9029 ios.width(0); 9030 { 9031 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9032 std::string ex(str, iter.base()); 9033 assert(ex == "-inf"); 9034 assert(ios.width() == 0); 9035 } 9036 ios.width(25); 9037 left(ios); 9038 { 9039 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9040 std::string ex(str, iter.base()); 9041 assert(ex == "-inf*********************"); 9042 assert(ios.width() == 0); 9043 } 9044 ios.width(25); 9045 right(ios); 9046 { 9047 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9048 std::string ex(str, iter.base()); 9049 assert(ex == "*********************-inf"); 9050 assert(ios.width() == 0); 9051 } 9052 ios.width(25); 9053 internal(ios); 9054 { 9055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9056 std::string ex(str, iter.base()); 9057 assert(ex == "-*********************inf"); 9058 assert(ios.width() == 0); 9059 } 9060 } 9061 ios.imbue(lg); 9062 { 9063 ios.width(0); 9064 { 9065 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9066 std::string ex(str, iter.base()); 9067 assert(ex == "-inf"); 9068 assert(ios.width() == 0); 9069 } 9070 ios.width(25); 9071 left(ios); 9072 { 9073 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9074 std::string ex(str, iter.base()); 9075 assert(ex == "-inf*********************"); 9076 assert(ios.width() == 0); 9077 } 9078 ios.width(25); 9079 right(ios); 9080 { 9081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9082 std::string ex(str, iter.base()); 9083 assert(ex == "*********************-inf"); 9084 assert(ios.width() == 0); 9085 } 9086 ios.width(25); 9087 internal(ios); 9088 { 9089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9090 std::string ex(str, iter.base()); 9091 assert(ex == "-*********************inf"); 9092 assert(ios.width() == 0); 9093 } 9094 } 9095 } 9096 } 9097 showpos(ios); 9098 { 9099 noshowpoint(ios); 9100 { 9101 ios.imbue(lc); 9102 { 9103 ios.width(0); 9104 { 9105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9106 std::string ex(str, iter.base()); 9107 assert(ex == "-inf"); 9108 assert(ios.width() == 0); 9109 } 9110 ios.width(25); 9111 left(ios); 9112 { 9113 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9114 std::string ex(str, iter.base()); 9115 assert(ex == "-inf*********************"); 9116 assert(ios.width() == 0); 9117 } 9118 ios.width(25); 9119 right(ios); 9120 { 9121 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9122 std::string ex(str, iter.base()); 9123 assert(ex == "*********************-inf"); 9124 assert(ios.width() == 0); 9125 } 9126 ios.width(25); 9127 internal(ios); 9128 { 9129 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9130 std::string ex(str, iter.base()); 9131 assert(ex == "-*********************inf"); 9132 assert(ios.width() == 0); 9133 } 9134 } 9135 ios.imbue(lg); 9136 { 9137 ios.width(0); 9138 { 9139 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9140 std::string ex(str, iter.base()); 9141 assert(ex == "-inf"); 9142 assert(ios.width() == 0); 9143 } 9144 ios.width(25); 9145 left(ios); 9146 { 9147 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9148 std::string ex(str, iter.base()); 9149 assert(ex == "-inf*********************"); 9150 assert(ios.width() == 0); 9151 } 9152 ios.width(25); 9153 right(ios); 9154 { 9155 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9156 std::string ex(str, iter.base()); 9157 assert(ex == "*********************-inf"); 9158 assert(ios.width() == 0); 9159 } 9160 ios.width(25); 9161 internal(ios); 9162 { 9163 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9164 std::string ex(str, iter.base()); 9165 assert(ex == "-*********************inf"); 9166 assert(ios.width() == 0); 9167 } 9168 } 9169 } 9170 showpoint(ios); 9171 { 9172 ios.imbue(lc); 9173 { 9174 ios.width(0); 9175 { 9176 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9177 std::string ex(str, iter.base()); 9178 assert(ex == "-inf"); 9179 assert(ios.width() == 0); 9180 } 9181 ios.width(25); 9182 left(ios); 9183 { 9184 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9185 std::string ex(str, iter.base()); 9186 assert(ex == "-inf*********************"); 9187 assert(ios.width() == 0); 9188 } 9189 ios.width(25); 9190 right(ios); 9191 { 9192 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9193 std::string ex(str, iter.base()); 9194 assert(ex == "*********************-inf"); 9195 assert(ios.width() == 0); 9196 } 9197 ios.width(25); 9198 internal(ios); 9199 { 9200 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9201 std::string ex(str, iter.base()); 9202 assert(ex == "-*********************inf"); 9203 assert(ios.width() == 0); 9204 } 9205 } 9206 ios.imbue(lg); 9207 { 9208 ios.width(0); 9209 { 9210 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9211 std::string ex(str, iter.base()); 9212 assert(ex == "-inf"); 9213 assert(ios.width() == 0); 9214 } 9215 ios.width(25); 9216 left(ios); 9217 { 9218 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9219 std::string ex(str, iter.base()); 9220 assert(ex == "-inf*********************"); 9221 assert(ios.width() == 0); 9222 } 9223 ios.width(25); 9224 right(ios); 9225 { 9226 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9227 std::string ex(str, iter.base()); 9228 assert(ex == "*********************-inf"); 9229 assert(ios.width() == 0); 9230 } 9231 ios.width(25); 9232 internal(ios); 9233 { 9234 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9235 std::string ex(str, iter.base()); 9236 assert(ex == "-*********************inf"); 9237 assert(ios.width() == 0); 9238 } 9239 } 9240 } 9241 } 9242 } 9243 uppercase(ios); 9244 { 9245 noshowpos(ios); 9246 { 9247 noshowpoint(ios); 9248 { 9249 ios.imbue(lc); 9250 { 9251 ios.width(0); 9252 { 9253 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9254 std::string ex(str, iter.base()); 9255 assert(ex == "-INF"); 9256 assert(ios.width() == 0); 9257 } 9258 ios.width(25); 9259 left(ios); 9260 { 9261 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9262 std::string ex(str, iter.base()); 9263 assert(ex == "-INF*********************"); 9264 assert(ios.width() == 0); 9265 } 9266 ios.width(25); 9267 right(ios); 9268 { 9269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9270 std::string ex(str, iter.base()); 9271 assert(ex == "*********************-INF"); 9272 assert(ios.width() == 0); 9273 } 9274 ios.width(25); 9275 internal(ios); 9276 { 9277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9278 std::string ex(str, iter.base()); 9279 assert(ex == "-*********************INF"); 9280 assert(ios.width() == 0); 9281 } 9282 } 9283 ios.imbue(lg); 9284 { 9285 ios.width(0); 9286 { 9287 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9288 std::string ex(str, iter.base()); 9289 assert(ex == "-INF"); 9290 assert(ios.width() == 0); 9291 } 9292 ios.width(25); 9293 left(ios); 9294 { 9295 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9296 std::string ex(str, iter.base()); 9297 assert(ex == "-INF*********************"); 9298 assert(ios.width() == 0); 9299 } 9300 ios.width(25); 9301 right(ios); 9302 { 9303 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9304 std::string ex(str, iter.base()); 9305 assert(ex == "*********************-INF"); 9306 assert(ios.width() == 0); 9307 } 9308 ios.width(25); 9309 internal(ios); 9310 { 9311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9312 std::string ex(str, iter.base()); 9313 assert(ex == "-*********************INF"); 9314 assert(ios.width() == 0); 9315 } 9316 } 9317 } 9318 showpoint(ios); 9319 { 9320 ios.imbue(lc); 9321 { 9322 ios.width(0); 9323 { 9324 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9325 std::string ex(str, iter.base()); 9326 assert(ex == "-INF"); 9327 assert(ios.width() == 0); 9328 } 9329 ios.width(25); 9330 left(ios); 9331 { 9332 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9333 std::string ex(str, iter.base()); 9334 assert(ex == "-INF*********************"); 9335 assert(ios.width() == 0); 9336 } 9337 ios.width(25); 9338 right(ios); 9339 { 9340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9341 std::string ex(str, iter.base()); 9342 assert(ex == "*********************-INF"); 9343 assert(ios.width() == 0); 9344 } 9345 ios.width(25); 9346 internal(ios); 9347 { 9348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9349 std::string ex(str, iter.base()); 9350 assert(ex == "-*********************INF"); 9351 assert(ios.width() == 0); 9352 } 9353 } 9354 ios.imbue(lg); 9355 { 9356 ios.width(0); 9357 { 9358 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9359 std::string ex(str, iter.base()); 9360 assert(ex == "-INF"); 9361 assert(ios.width() == 0); 9362 } 9363 ios.width(25); 9364 left(ios); 9365 { 9366 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9367 std::string ex(str, iter.base()); 9368 assert(ex == "-INF*********************"); 9369 assert(ios.width() == 0); 9370 } 9371 ios.width(25); 9372 right(ios); 9373 { 9374 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9375 std::string ex(str, iter.base()); 9376 assert(ex == "*********************-INF"); 9377 assert(ios.width() == 0); 9378 } 9379 ios.width(25); 9380 internal(ios); 9381 { 9382 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9383 std::string ex(str, iter.base()); 9384 assert(ex == "-*********************INF"); 9385 assert(ios.width() == 0); 9386 } 9387 } 9388 } 9389 } 9390 showpos(ios); 9391 { 9392 noshowpoint(ios); 9393 { 9394 ios.imbue(lc); 9395 { 9396 ios.width(0); 9397 { 9398 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9399 std::string ex(str, iter.base()); 9400 assert(ex == "-INF"); 9401 assert(ios.width() == 0); 9402 } 9403 ios.width(25); 9404 left(ios); 9405 { 9406 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9407 std::string ex(str, iter.base()); 9408 assert(ex == "-INF*********************"); 9409 assert(ios.width() == 0); 9410 } 9411 ios.width(25); 9412 right(ios); 9413 { 9414 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9415 std::string ex(str, iter.base()); 9416 assert(ex == "*********************-INF"); 9417 assert(ios.width() == 0); 9418 } 9419 ios.width(25); 9420 internal(ios); 9421 { 9422 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9423 std::string ex(str, iter.base()); 9424 assert(ex == "-*********************INF"); 9425 assert(ios.width() == 0); 9426 } 9427 } 9428 ios.imbue(lg); 9429 { 9430 ios.width(0); 9431 { 9432 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9433 std::string ex(str, iter.base()); 9434 assert(ex == "-INF"); 9435 assert(ios.width() == 0); 9436 } 9437 ios.width(25); 9438 left(ios); 9439 { 9440 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9441 std::string ex(str, iter.base()); 9442 assert(ex == "-INF*********************"); 9443 assert(ios.width() == 0); 9444 } 9445 ios.width(25); 9446 right(ios); 9447 { 9448 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9449 std::string ex(str, iter.base()); 9450 assert(ex == "*********************-INF"); 9451 assert(ios.width() == 0); 9452 } 9453 ios.width(25); 9454 internal(ios); 9455 { 9456 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9457 std::string ex(str, iter.base()); 9458 assert(ex == "-*********************INF"); 9459 assert(ios.width() == 0); 9460 } 9461 } 9462 } 9463 showpoint(ios); 9464 { 9465 ios.imbue(lc); 9466 { 9467 ios.width(0); 9468 { 9469 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9470 std::string ex(str, iter.base()); 9471 assert(ex == "-INF"); 9472 assert(ios.width() == 0); 9473 } 9474 ios.width(25); 9475 left(ios); 9476 { 9477 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9478 std::string ex(str, iter.base()); 9479 assert(ex == "-INF*********************"); 9480 assert(ios.width() == 0); 9481 } 9482 ios.width(25); 9483 right(ios); 9484 { 9485 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9486 std::string ex(str, iter.base()); 9487 assert(ex == "*********************-INF"); 9488 assert(ios.width() == 0); 9489 } 9490 ios.width(25); 9491 internal(ios); 9492 { 9493 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9494 std::string ex(str, iter.base()); 9495 assert(ex == "-*********************INF"); 9496 assert(ios.width() == 0); 9497 } 9498 } 9499 ios.imbue(lg); 9500 { 9501 ios.width(0); 9502 { 9503 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9504 std::string ex(str, iter.base()); 9505 assert(ex == "-INF"); 9506 assert(ios.width() == 0); 9507 } 9508 ios.width(25); 9509 left(ios); 9510 { 9511 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9512 std::string ex(str, iter.base()); 9513 assert(ex == "-INF*********************"); 9514 assert(ios.width() == 0); 9515 } 9516 ios.width(25); 9517 right(ios); 9518 { 9519 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9520 std::string ex(str, iter.base()); 9521 assert(ex == "*********************-INF"); 9522 assert(ios.width() == 0); 9523 } 9524 ios.width(25); 9525 internal(ios); 9526 { 9527 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9528 std::string ex(str, iter.base()); 9529 assert(ex == "-*********************INF"); 9530 assert(ios.width() == 0); 9531 } 9532 } 9533 } 9534 } 9535 } 9536 } 9537 ios.precision(1); 9538 { 9539 nouppercase(ios); 9540 { 9541 noshowpos(ios); 9542 { 9543 noshowpoint(ios); 9544 { 9545 ios.imbue(lc); 9546 { 9547 ios.width(0); 9548 { 9549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9550 std::string ex(str, iter.base()); 9551 assert(ex == "-inf"); 9552 assert(ios.width() == 0); 9553 } 9554 ios.width(25); 9555 left(ios); 9556 { 9557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9558 std::string ex(str, iter.base()); 9559 assert(ex == "-inf*********************"); 9560 assert(ios.width() == 0); 9561 } 9562 ios.width(25); 9563 right(ios); 9564 { 9565 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9566 std::string ex(str, iter.base()); 9567 assert(ex == "*********************-inf"); 9568 assert(ios.width() == 0); 9569 } 9570 ios.width(25); 9571 internal(ios); 9572 { 9573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9574 std::string ex(str, iter.base()); 9575 assert(ex == "-*********************inf"); 9576 assert(ios.width() == 0); 9577 } 9578 } 9579 ios.imbue(lg); 9580 { 9581 ios.width(0); 9582 { 9583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9584 std::string ex(str, iter.base()); 9585 assert(ex == "-inf"); 9586 assert(ios.width() == 0); 9587 } 9588 ios.width(25); 9589 left(ios); 9590 { 9591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9592 std::string ex(str, iter.base()); 9593 assert(ex == "-inf*********************"); 9594 assert(ios.width() == 0); 9595 } 9596 ios.width(25); 9597 right(ios); 9598 { 9599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9600 std::string ex(str, iter.base()); 9601 assert(ex == "*********************-inf"); 9602 assert(ios.width() == 0); 9603 } 9604 ios.width(25); 9605 internal(ios); 9606 { 9607 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9608 std::string ex(str, iter.base()); 9609 assert(ex == "-*********************inf"); 9610 assert(ios.width() == 0); 9611 } 9612 } 9613 } 9614 showpoint(ios); 9615 { 9616 ios.imbue(lc); 9617 { 9618 ios.width(0); 9619 { 9620 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9621 std::string ex(str, iter.base()); 9622 assert(ex == "-inf"); 9623 assert(ios.width() == 0); 9624 } 9625 ios.width(25); 9626 left(ios); 9627 { 9628 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9629 std::string ex(str, iter.base()); 9630 assert(ex == "-inf*********************"); 9631 assert(ios.width() == 0); 9632 } 9633 ios.width(25); 9634 right(ios); 9635 { 9636 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9637 std::string ex(str, iter.base()); 9638 assert(ex == "*********************-inf"); 9639 assert(ios.width() == 0); 9640 } 9641 ios.width(25); 9642 internal(ios); 9643 { 9644 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9645 std::string ex(str, iter.base()); 9646 assert(ex == "-*********************inf"); 9647 assert(ios.width() == 0); 9648 } 9649 } 9650 ios.imbue(lg); 9651 { 9652 ios.width(0); 9653 { 9654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9655 std::string ex(str, iter.base()); 9656 assert(ex == "-inf"); 9657 assert(ios.width() == 0); 9658 } 9659 ios.width(25); 9660 left(ios); 9661 { 9662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9663 std::string ex(str, iter.base()); 9664 assert(ex == "-inf*********************"); 9665 assert(ios.width() == 0); 9666 } 9667 ios.width(25); 9668 right(ios); 9669 { 9670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9671 std::string ex(str, iter.base()); 9672 assert(ex == "*********************-inf"); 9673 assert(ios.width() == 0); 9674 } 9675 ios.width(25); 9676 internal(ios); 9677 { 9678 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9679 std::string ex(str, iter.base()); 9680 assert(ex == "-*********************inf"); 9681 assert(ios.width() == 0); 9682 } 9683 } 9684 } 9685 } 9686 showpos(ios); 9687 { 9688 noshowpoint(ios); 9689 { 9690 ios.imbue(lc); 9691 { 9692 ios.width(0); 9693 { 9694 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9695 std::string ex(str, iter.base()); 9696 assert(ex == "-inf"); 9697 assert(ios.width() == 0); 9698 } 9699 ios.width(25); 9700 left(ios); 9701 { 9702 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9703 std::string ex(str, iter.base()); 9704 assert(ex == "-inf*********************"); 9705 assert(ios.width() == 0); 9706 } 9707 ios.width(25); 9708 right(ios); 9709 { 9710 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9711 std::string ex(str, iter.base()); 9712 assert(ex == "*********************-inf"); 9713 assert(ios.width() == 0); 9714 } 9715 ios.width(25); 9716 internal(ios); 9717 { 9718 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9719 std::string ex(str, iter.base()); 9720 assert(ex == "-*********************inf"); 9721 assert(ios.width() == 0); 9722 } 9723 } 9724 ios.imbue(lg); 9725 { 9726 ios.width(0); 9727 { 9728 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9729 std::string ex(str, iter.base()); 9730 assert(ex == "-inf"); 9731 assert(ios.width() == 0); 9732 } 9733 ios.width(25); 9734 left(ios); 9735 { 9736 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9737 std::string ex(str, iter.base()); 9738 assert(ex == "-inf*********************"); 9739 assert(ios.width() == 0); 9740 } 9741 ios.width(25); 9742 right(ios); 9743 { 9744 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9745 std::string ex(str, iter.base()); 9746 assert(ex == "*********************-inf"); 9747 assert(ios.width() == 0); 9748 } 9749 ios.width(25); 9750 internal(ios); 9751 { 9752 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9753 std::string ex(str, iter.base()); 9754 assert(ex == "-*********************inf"); 9755 assert(ios.width() == 0); 9756 } 9757 } 9758 } 9759 showpoint(ios); 9760 { 9761 ios.imbue(lc); 9762 { 9763 ios.width(0); 9764 { 9765 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9766 std::string ex(str, iter.base()); 9767 assert(ex == "-inf"); 9768 assert(ios.width() == 0); 9769 } 9770 ios.width(25); 9771 left(ios); 9772 { 9773 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9774 std::string ex(str, iter.base()); 9775 assert(ex == "-inf*********************"); 9776 assert(ios.width() == 0); 9777 } 9778 ios.width(25); 9779 right(ios); 9780 { 9781 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9782 std::string ex(str, iter.base()); 9783 assert(ex == "*********************-inf"); 9784 assert(ios.width() == 0); 9785 } 9786 ios.width(25); 9787 internal(ios); 9788 { 9789 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9790 std::string ex(str, iter.base()); 9791 assert(ex == "-*********************inf"); 9792 assert(ios.width() == 0); 9793 } 9794 } 9795 ios.imbue(lg); 9796 { 9797 ios.width(0); 9798 { 9799 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9800 std::string ex(str, iter.base()); 9801 assert(ex == "-inf"); 9802 assert(ios.width() == 0); 9803 } 9804 ios.width(25); 9805 left(ios); 9806 { 9807 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9808 std::string ex(str, iter.base()); 9809 assert(ex == "-inf*********************"); 9810 assert(ios.width() == 0); 9811 } 9812 ios.width(25); 9813 right(ios); 9814 { 9815 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9816 std::string ex(str, iter.base()); 9817 assert(ex == "*********************-inf"); 9818 assert(ios.width() == 0); 9819 } 9820 ios.width(25); 9821 internal(ios); 9822 { 9823 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9824 std::string ex(str, iter.base()); 9825 assert(ex == "-*********************inf"); 9826 assert(ios.width() == 0); 9827 } 9828 } 9829 } 9830 } 9831 } 9832 uppercase(ios); 9833 { 9834 noshowpos(ios); 9835 { 9836 noshowpoint(ios); 9837 { 9838 ios.imbue(lc); 9839 { 9840 ios.width(0); 9841 { 9842 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9843 std::string ex(str, iter.base()); 9844 assert(ex == "-INF"); 9845 assert(ios.width() == 0); 9846 } 9847 ios.width(25); 9848 left(ios); 9849 { 9850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9851 std::string ex(str, iter.base()); 9852 assert(ex == "-INF*********************"); 9853 assert(ios.width() == 0); 9854 } 9855 ios.width(25); 9856 right(ios); 9857 { 9858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9859 std::string ex(str, iter.base()); 9860 assert(ex == "*********************-INF"); 9861 assert(ios.width() == 0); 9862 } 9863 ios.width(25); 9864 internal(ios); 9865 { 9866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9867 std::string ex(str, iter.base()); 9868 assert(ex == "-*********************INF"); 9869 assert(ios.width() == 0); 9870 } 9871 } 9872 ios.imbue(lg); 9873 { 9874 ios.width(0); 9875 { 9876 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9877 std::string ex(str, iter.base()); 9878 assert(ex == "-INF"); 9879 assert(ios.width() == 0); 9880 } 9881 ios.width(25); 9882 left(ios); 9883 { 9884 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9885 std::string ex(str, iter.base()); 9886 assert(ex == "-INF*********************"); 9887 assert(ios.width() == 0); 9888 } 9889 ios.width(25); 9890 right(ios); 9891 { 9892 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9893 std::string ex(str, iter.base()); 9894 assert(ex == "*********************-INF"); 9895 assert(ios.width() == 0); 9896 } 9897 ios.width(25); 9898 internal(ios); 9899 { 9900 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9901 std::string ex(str, iter.base()); 9902 assert(ex == "-*********************INF"); 9903 assert(ios.width() == 0); 9904 } 9905 } 9906 } 9907 showpoint(ios); 9908 { 9909 ios.imbue(lc); 9910 { 9911 ios.width(0); 9912 { 9913 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9914 std::string ex(str, iter.base()); 9915 assert(ex == "-INF"); 9916 assert(ios.width() == 0); 9917 } 9918 ios.width(25); 9919 left(ios); 9920 { 9921 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9922 std::string ex(str, iter.base()); 9923 assert(ex == "-INF*********************"); 9924 assert(ios.width() == 0); 9925 } 9926 ios.width(25); 9927 right(ios); 9928 { 9929 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9930 std::string ex(str, iter.base()); 9931 assert(ex == "*********************-INF"); 9932 assert(ios.width() == 0); 9933 } 9934 ios.width(25); 9935 internal(ios); 9936 { 9937 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9938 std::string ex(str, iter.base()); 9939 assert(ex == "-*********************INF"); 9940 assert(ios.width() == 0); 9941 } 9942 } 9943 ios.imbue(lg); 9944 { 9945 ios.width(0); 9946 { 9947 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9948 std::string ex(str, iter.base()); 9949 assert(ex == "-INF"); 9950 assert(ios.width() == 0); 9951 } 9952 ios.width(25); 9953 left(ios); 9954 { 9955 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9956 std::string ex(str, iter.base()); 9957 assert(ex == "-INF*********************"); 9958 assert(ios.width() == 0); 9959 } 9960 ios.width(25); 9961 right(ios); 9962 { 9963 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9964 std::string ex(str, iter.base()); 9965 assert(ex == "*********************-INF"); 9966 assert(ios.width() == 0); 9967 } 9968 ios.width(25); 9969 internal(ios); 9970 { 9971 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9972 std::string ex(str, iter.base()); 9973 assert(ex == "-*********************INF"); 9974 assert(ios.width() == 0); 9975 } 9976 } 9977 } 9978 } 9979 showpos(ios); 9980 { 9981 noshowpoint(ios); 9982 { 9983 ios.imbue(lc); 9984 { 9985 ios.width(0); 9986 { 9987 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9988 std::string ex(str, iter.base()); 9989 assert(ex == "-INF"); 9990 assert(ios.width() == 0); 9991 } 9992 ios.width(25); 9993 left(ios); 9994 { 9995 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9996 std::string ex(str, iter.base()); 9997 assert(ex == "-INF*********************"); 9998 assert(ios.width() == 0); 9999 } 10000 ios.width(25); 10001 right(ios); 10002 { 10003 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10004 std::string ex(str, iter.base()); 10005 assert(ex == "*********************-INF"); 10006 assert(ios.width() == 0); 10007 } 10008 ios.width(25); 10009 internal(ios); 10010 { 10011 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10012 std::string ex(str, iter.base()); 10013 assert(ex == "-*********************INF"); 10014 assert(ios.width() == 0); 10015 } 10016 } 10017 ios.imbue(lg); 10018 { 10019 ios.width(0); 10020 { 10021 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10022 std::string ex(str, iter.base()); 10023 assert(ex == "-INF"); 10024 assert(ios.width() == 0); 10025 } 10026 ios.width(25); 10027 left(ios); 10028 { 10029 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10030 std::string ex(str, iter.base()); 10031 assert(ex == "-INF*********************"); 10032 assert(ios.width() == 0); 10033 } 10034 ios.width(25); 10035 right(ios); 10036 { 10037 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10038 std::string ex(str, iter.base()); 10039 assert(ex == "*********************-INF"); 10040 assert(ios.width() == 0); 10041 } 10042 ios.width(25); 10043 internal(ios); 10044 { 10045 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10046 std::string ex(str, iter.base()); 10047 assert(ex == "-*********************INF"); 10048 assert(ios.width() == 0); 10049 } 10050 } 10051 } 10052 showpoint(ios); 10053 { 10054 ios.imbue(lc); 10055 { 10056 ios.width(0); 10057 { 10058 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10059 std::string ex(str, iter.base()); 10060 assert(ex == "-INF"); 10061 assert(ios.width() == 0); 10062 } 10063 ios.width(25); 10064 left(ios); 10065 { 10066 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10067 std::string ex(str, iter.base()); 10068 assert(ex == "-INF*********************"); 10069 assert(ios.width() == 0); 10070 } 10071 ios.width(25); 10072 right(ios); 10073 { 10074 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10075 std::string ex(str, iter.base()); 10076 assert(ex == "*********************-INF"); 10077 assert(ios.width() == 0); 10078 } 10079 ios.width(25); 10080 internal(ios); 10081 { 10082 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10083 std::string ex(str, iter.base()); 10084 assert(ex == "-*********************INF"); 10085 assert(ios.width() == 0); 10086 } 10087 } 10088 ios.imbue(lg); 10089 { 10090 ios.width(0); 10091 { 10092 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10093 std::string ex(str, iter.base()); 10094 assert(ex == "-INF"); 10095 assert(ios.width() == 0); 10096 } 10097 ios.width(25); 10098 left(ios); 10099 { 10100 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10101 std::string ex(str, iter.base()); 10102 assert(ex == "-INF*********************"); 10103 assert(ios.width() == 0); 10104 } 10105 ios.width(25); 10106 right(ios); 10107 { 10108 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10109 std::string ex(str, iter.base()); 10110 assert(ex == "*********************-INF"); 10111 assert(ios.width() == 0); 10112 } 10113 ios.width(25); 10114 internal(ios); 10115 { 10116 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10117 std::string ex(str, iter.base()); 10118 assert(ex == "-*********************INF"); 10119 assert(ios.width() == 0); 10120 } 10121 } 10122 } 10123 } 10124 } 10125 } 10126 ios.precision(6); 10127 { 10128 nouppercase(ios); 10129 { 10130 noshowpos(ios); 10131 { 10132 noshowpoint(ios); 10133 { 10134 ios.imbue(lc); 10135 { 10136 ios.width(0); 10137 { 10138 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10139 std::string ex(str, iter.base()); 10140 assert(ex == "-inf"); 10141 assert(ios.width() == 0); 10142 } 10143 ios.width(25); 10144 left(ios); 10145 { 10146 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10147 std::string ex(str, iter.base()); 10148 assert(ex == "-inf*********************"); 10149 assert(ios.width() == 0); 10150 } 10151 ios.width(25); 10152 right(ios); 10153 { 10154 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10155 std::string ex(str, iter.base()); 10156 assert(ex == "*********************-inf"); 10157 assert(ios.width() == 0); 10158 } 10159 ios.width(25); 10160 internal(ios); 10161 { 10162 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10163 std::string ex(str, iter.base()); 10164 assert(ex == "-*********************inf"); 10165 assert(ios.width() == 0); 10166 } 10167 } 10168 ios.imbue(lg); 10169 { 10170 ios.width(0); 10171 { 10172 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10173 std::string ex(str, iter.base()); 10174 assert(ex == "-inf"); 10175 assert(ios.width() == 0); 10176 } 10177 ios.width(25); 10178 left(ios); 10179 { 10180 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10181 std::string ex(str, iter.base()); 10182 assert(ex == "-inf*********************"); 10183 assert(ios.width() == 0); 10184 } 10185 ios.width(25); 10186 right(ios); 10187 { 10188 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10189 std::string ex(str, iter.base()); 10190 assert(ex == "*********************-inf"); 10191 assert(ios.width() == 0); 10192 } 10193 ios.width(25); 10194 internal(ios); 10195 { 10196 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10197 std::string ex(str, iter.base()); 10198 assert(ex == "-*********************inf"); 10199 assert(ios.width() == 0); 10200 } 10201 } 10202 } 10203 showpoint(ios); 10204 { 10205 ios.imbue(lc); 10206 { 10207 ios.width(0); 10208 { 10209 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10210 std::string ex(str, iter.base()); 10211 assert(ex == "-inf"); 10212 assert(ios.width() == 0); 10213 } 10214 ios.width(25); 10215 left(ios); 10216 { 10217 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10218 std::string ex(str, iter.base()); 10219 assert(ex == "-inf*********************"); 10220 assert(ios.width() == 0); 10221 } 10222 ios.width(25); 10223 right(ios); 10224 { 10225 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10226 std::string ex(str, iter.base()); 10227 assert(ex == "*********************-inf"); 10228 assert(ios.width() == 0); 10229 } 10230 ios.width(25); 10231 internal(ios); 10232 { 10233 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10234 std::string ex(str, iter.base()); 10235 assert(ex == "-*********************inf"); 10236 assert(ios.width() == 0); 10237 } 10238 } 10239 ios.imbue(lg); 10240 { 10241 ios.width(0); 10242 { 10243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10244 std::string ex(str, iter.base()); 10245 assert(ex == "-inf"); 10246 assert(ios.width() == 0); 10247 } 10248 ios.width(25); 10249 left(ios); 10250 { 10251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10252 std::string ex(str, iter.base()); 10253 assert(ex == "-inf*********************"); 10254 assert(ios.width() == 0); 10255 } 10256 ios.width(25); 10257 right(ios); 10258 { 10259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10260 std::string ex(str, iter.base()); 10261 assert(ex == "*********************-inf"); 10262 assert(ios.width() == 0); 10263 } 10264 ios.width(25); 10265 internal(ios); 10266 { 10267 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10268 std::string ex(str, iter.base()); 10269 assert(ex == "-*********************inf"); 10270 assert(ios.width() == 0); 10271 } 10272 } 10273 } 10274 } 10275 showpos(ios); 10276 { 10277 noshowpoint(ios); 10278 { 10279 ios.imbue(lc); 10280 { 10281 ios.width(0); 10282 { 10283 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10284 std::string ex(str, iter.base()); 10285 assert(ex == "-inf"); 10286 assert(ios.width() == 0); 10287 } 10288 ios.width(25); 10289 left(ios); 10290 { 10291 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10292 std::string ex(str, iter.base()); 10293 assert(ex == "-inf*********************"); 10294 assert(ios.width() == 0); 10295 } 10296 ios.width(25); 10297 right(ios); 10298 { 10299 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10300 std::string ex(str, iter.base()); 10301 assert(ex == "*********************-inf"); 10302 assert(ios.width() == 0); 10303 } 10304 ios.width(25); 10305 internal(ios); 10306 { 10307 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10308 std::string ex(str, iter.base()); 10309 assert(ex == "-*********************inf"); 10310 assert(ios.width() == 0); 10311 } 10312 } 10313 ios.imbue(lg); 10314 { 10315 ios.width(0); 10316 { 10317 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10318 std::string ex(str, iter.base()); 10319 assert(ex == "-inf"); 10320 assert(ios.width() == 0); 10321 } 10322 ios.width(25); 10323 left(ios); 10324 { 10325 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10326 std::string ex(str, iter.base()); 10327 assert(ex == "-inf*********************"); 10328 assert(ios.width() == 0); 10329 } 10330 ios.width(25); 10331 right(ios); 10332 { 10333 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10334 std::string ex(str, iter.base()); 10335 assert(ex == "*********************-inf"); 10336 assert(ios.width() == 0); 10337 } 10338 ios.width(25); 10339 internal(ios); 10340 { 10341 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10342 std::string ex(str, iter.base()); 10343 assert(ex == "-*********************inf"); 10344 assert(ios.width() == 0); 10345 } 10346 } 10347 } 10348 showpoint(ios); 10349 { 10350 ios.imbue(lc); 10351 { 10352 ios.width(0); 10353 { 10354 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10355 std::string ex(str, iter.base()); 10356 assert(ex == "-inf"); 10357 assert(ios.width() == 0); 10358 } 10359 ios.width(25); 10360 left(ios); 10361 { 10362 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10363 std::string ex(str, iter.base()); 10364 assert(ex == "-inf*********************"); 10365 assert(ios.width() == 0); 10366 } 10367 ios.width(25); 10368 right(ios); 10369 { 10370 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10371 std::string ex(str, iter.base()); 10372 assert(ex == "*********************-inf"); 10373 assert(ios.width() == 0); 10374 } 10375 ios.width(25); 10376 internal(ios); 10377 { 10378 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10379 std::string ex(str, iter.base()); 10380 assert(ex == "-*********************inf"); 10381 assert(ios.width() == 0); 10382 } 10383 } 10384 ios.imbue(lg); 10385 { 10386 ios.width(0); 10387 { 10388 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10389 std::string ex(str, iter.base()); 10390 assert(ex == "-inf"); 10391 assert(ios.width() == 0); 10392 } 10393 ios.width(25); 10394 left(ios); 10395 { 10396 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10397 std::string ex(str, iter.base()); 10398 assert(ex == "-inf*********************"); 10399 assert(ios.width() == 0); 10400 } 10401 ios.width(25); 10402 right(ios); 10403 { 10404 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10405 std::string ex(str, iter.base()); 10406 assert(ex == "*********************-inf"); 10407 assert(ios.width() == 0); 10408 } 10409 ios.width(25); 10410 internal(ios); 10411 { 10412 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10413 std::string ex(str, iter.base()); 10414 assert(ex == "-*********************inf"); 10415 assert(ios.width() == 0); 10416 } 10417 } 10418 } 10419 } 10420 } 10421 uppercase(ios); 10422 { 10423 noshowpos(ios); 10424 { 10425 noshowpoint(ios); 10426 { 10427 ios.imbue(lc); 10428 { 10429 ios.width(0); 10430 { 10431 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10432 std::string ex(str, iter.base()); 10433 assert(ex == "-INF"); 10434 assert(ios.width() == 0); 10435 } 10436 ios.width(25); 10437 left(ios); 10438 { 10439 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10440 std::string ex(str, iter.base()); 10441 assert(ex == "-INF*********************"); 10442 assert(ios.width() == 0); 10443 } 10444 ios.width(25); 10445 right(ios); 10446 { 10447 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10448 std::string ex(str, iter.base()); 10449 assert(ex == "*********************-INF"); 10450 assert(ios.width() == 0); 10451 } 10452 ios.width(25); 10453 internal(ios); 10454 { 10455 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10456 std::string ex(str, iter.base()); 10457 assert(ex == "-*********************INF"); 10458 assert(ios.width() == 0); 10459 } 10460 } 10461 ios.imbue(lg); 10462 { 10463 ios.width(0); 10464 { 10465 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10466 std::string ex(str, iter.base()); 10467 assert(ex == "-INF"); 10468 assert(ios.width() == 0); 10469 } 10470 ios.width(25); 10471 left(ios); 10472 { 10473 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10474 std::string ex(str, iter.base()); 10475 assert(ex == "-INF*********************"); 10476 assert(ios.width() == 0); 10477 } 10478 ios.width(25); 10479 right(ios); 10480 { 10481 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10482 std::string ex(str, iter.base()); 10483 assert(ex == "*********************-INF"); 10484 assert(ios.width() == 0); 10485 } 10486 ios.width(25); 10487 internal(ios); 10488 { 10489 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10490 std::string ex(str, iter.base()); 10491 assert(ex == "-*********************INF"); 10492 assert(ios.width() == 0); 10493 } 10494 } 10495 } 10496 showpoint(ios); 10497 { 10498 ios.imbue(lc); 10499 { 10500 ios.width(0); 10501 { 10502 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10503 std::string ex(str, iter.base()); 10504 assert(ex == "-INF"); 10505 assert(ios.width() == 0); 10506 } 10507 ios.width(25); 10508 left(ios); 10509 { 10510 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10511 std::string ex(str, iter.base()); 10512 assert(ex == "-INF*********************"); 10513 assert(ios.width() == 0); 10514 } 10515 ios.width(25); 10516 right(ios); 10517 { 10518 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10519 std::string ex(str, iter.base()); 10520 assert(ex == "*********************-INF"); 10521 assert(ios.width() == 0); 10522 } 10523 ios.width(25); 10524 internal(ios); 10525 { 10526 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10527 std::string ex(str, iter.base()); 10528 assert(ex == "-*********************INF"); 10529 assert(ios.width() == 0); 10530 } 10531 } 10532 ios.imbue(lg); 10533 { 10534 ios.width(0); 10535 { 10536 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10537 std::string ex(str, iter.base()); 10538 assert(ex == "-INF"); 10539 assert(ios.width() == 0); 10540 } 10541 ios.width(25); 10542 left(ios); 10543 { 10544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10545 std::string ex(str, iter.base()); 10546 assert(ex == "-INF*********************"); 10547 assert(ios.width() == 0); 10548 } 10549 ios.width(25); 10550 right(ios); 10551 { 10552 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10553 std::string ex(str, iter.base()); 10554 assert(ex == "*********************-INF"); 10555 assert(ios.width() == 0); 10556 } 10557 ios.width(25); 10558 internal(ios); 10559 { 10560 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10561 std::string ex(str, iter.base()); 10562 assert(ex == "-*********************INF"); 10563 assert(ios.width() == 0); 10564 } 10565 } 10566 } 10567 } 10568 showpos(ios); 10569 { 10570 noshowpoint(ios); 10571 { 10572 ios.imbue(lc); 10573 { 10574 ios.width(0); 10575 { 10576 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10577 std::string ex(str, iter.base()); 10578 assert(ex == "-INF"); 10579 assert(ios.width() == 0); 10580 } 10581 ios.width(25); 10582 left(ios); 10583 { 10584 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10585 std::string ex(str, iter.base()); 10586 assert(ex == "-INF*********************"); 10587 assert(ios.width() == 0); 10588 } 10589 ios.width(25); 10590 right(ios); 10591 { 10592 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10593 std::string ex(str, iter.base()); 10594 assert(ex == "*********************-INF"); 10595 assert(ios.width() == 0); 10596 } 10597 ios.width(25); 10598 internal(ios); 10599 { 10600 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10601 std::string ex(str, iter.base()); 10602 assert(ex == "-*********************INF"); 10603 assert(ios.width() == 0); 10604 } 10605 } 10606 ios.imbue(lg); 10607 { 10608 ios.width(0); 10609 { 10610 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10611 std::string ex(str, iter.base()); 10612 assert(ex == "-INF"); 10613 assert(ios.width() == 0); 10614 } 10615 ios.width(25); 10616 left(ios); 10617 { 10618 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10619 std::string ex(str, iter.base()); 10620 assert(ex == "-INF*********************"); 10621 assert(ios.width() == 0); 10622 } 10623 ios.width(25); 10624 right(ios); 10625 { 10626 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10627 std::string ex(str, iter.base()); 10628 assert(ex == "*********************-INF"); 10629 assert(ios.width() == 0); 10630 } 10631 ios.width(25); 10632 internal(ios); 10633 { 10634 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10635 std::string ex(str, iter.base()); 10636 assert(ex == "-*********************INF"); 10637 assert(ios.width() == 0); 10638 } 10639 } 10640 } 10641 showpoint(ios); 10642 { 10643 ios.imbue(lc); 10644 { 10645 ios.width(0); 10646 { 10647 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10648 std::string ex(str, iter.base()); 10649 assert(ex == "-INF"); 10650 assert(ios.width() == 0); 10651 } 10652 ios.width(25); 10653 left(ios); 10654 { 10655 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10656 std::string ex(str, iter.base()); 10657 assert(ex == "-INF*********************"); 10658 assert(ios.width() == 0); 10659 } 10660 ios.width(25); 10661 right(ios); 10662 { 10663 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10664 std::string ex(str, iter.base()); 10665 assert(ex == "*********************-INF"); 10666 assert(ios.width() == 0); 10667 } 10668 ios.width(25); 10669 internal(ios); 10670 { 10671 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10672 std::string ex(str, iter.base()); 10673 assert(ex == "-*********************INF"); 10674 assert(ios.width() == 0); 10675 } 10676 } 10677 ios.imbue(lg); 10678 { 10679 ios.width(0); 10680 { 10681 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10682 std::string ex(str, iter.base()); 10683 assert(ex == "-INF"); 10684 assert(ios.width() == 0); 10685 } 10686 ios.width(25); 10687 left(ios); 10688 { 10689 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10690 std::string ex(str, iter.base()); 10691 assert(ex == "-INF*********************"); 10692 assert(ios.width() == 0); 10693 } 10694 ios.width(25); 10695 right(ios); 10696 { 10697 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10698 std::string ex(str, iter.base()); 10699 assert(ex == "*********************-INF"); 10700 assert(ios.width() == 0); 10701 } 10702 ios.width(25); 10703 internal(ios); 10704 { 10705 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10706 std::string ex(str, iter.base()); 10707 assert(ex == "-*********************INF"); 10708 assert(ios.width() == 0); 10709 } 10710 } 10711 } 10712 } 10713 } 10714 } 10715 ios.precision(16); 10716 {} 10717 ios.precision(60); 10718 {} 10719 } 10720 } 10721 } 10722 10723 void test5() 10724 { 10725 char str[200]; 10726 output_iterator<char*> iter; 10727 std::locale lc = std::locale::classic(); 10728 std::locale lg(lc, new my_numpunct); 10729 const my_facet f(1); 10730 { 10731 long double v = std::nan(""); 10732 std::ios ios(0); 10733 // %g 10734 { 10735 ios.precision(0); 10736 { 10737 nouppercase(ios); 10738 { 10739 noshowpos(ios); 10740 { 10741 noshowpoint(ios); 10742 { 10743 ios.imbue(lc); 10744 { 10745 ios.width(0); 10746 { 10747 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10748 std::string ex(str, iter.base()); 10749 assert(ex == "nan"); 10750 assert(ios.width() == 0); 10751 } 10752 ios.width(25); 10753 left(ios); 10754 { 10755 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10756 std::string ex(str, iter.base()); 10757 assert(ex == "nan**********************"); 10758 assert(ios.width() == 0); 10759 } 10760 ios.width(25); 10761 right(ios); 10762 { 10763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10764 std::string ex(str, iter.base()); 10765 assert(ex == "**********************nan"); 10766 assert(ios.width() == 0); 10767 } 10768 ios.width(25); 10769 internal(ios); 10770 { 10771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10772 std::string ex(str, iter.base()); 10773 assert(ex == "**********************nan"); 10774 assert(ios.width() == 0); 10775 } 10776 } 10777 ios.imbue(lg); 10778 { 10779 ios.width(0); 10780 { 10781 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10782 std::string ex(str, iter.base()); 10783 assert(ex == "nan"); 10784 assert(ios.width() == 0); 10785 } 10786 ios.width(25); 10787 left(ios); 10788 { 10789 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10790 std::string ex(str, iter.base()); 10791 assert(ex == "nan**********************"); 10792 assert(ios.width() == 0); 10793 } 10794 ios.width(25); 10795 right(ios); 10796 { 10797 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10798 std::string ex(str, iter.base()); 10799 assert(ex == "**********************nan"); 10800 assert(ios.width() == 0); 10801 } 10802 ios.width(25); 10803 internal(ios); 10804 { 10805 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10806 std::string ex(str, iter.base()); 10807 assert(ex == "**********************nan"); 10808 assert(ios.width() == 0); 10809 } 10810 } 10811 } 10812 showpoint(ios); 10813 { 10814 ios.imbue(lc); 10815 { 10816 ios.width(0); 10817 { 10818 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10819 std::string ex(str, iter.base()); 10820 assert(ex == "nan"); 10821 assert(ios.width() == 0); 10822 } 10823 ios.width(25); 10824 left(ios); 10825 { 10826 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10827 std::string ex(str, iter.base()); 10828 assert(ex == "nan**********************"); 10829 assert(ios.width() == 0); 10830 } 10831 ios.width(25); 10832 right(ios); 10833 { 10834 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10835 std::string ex(str, iter.base()); 10836 assert(ex == "**********************nan"); 10837 assert(ios.width() == 0); 10838 } 10839 ios.width(25); 10840 internal(ios); 10841 { 10842 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10843 std::string ex(str, iter.base()); 10844 assert(ex == "**********************nan"); 10845 assert(ios.width() == 0); 10846 } 10847 } 10848 ios.imbue(lg); 10849 { 10850 ios.width(0); 10851 { 10852 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10853 std::string ex(str, iter.base()); 10854 assert(ex == "nan"); 10855 assert(ios.width() == 0); 10856 } 10857 ios.width(25); 10858 left(ios); 10859 { 10860 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10861 std::string ex(str, iter.base()); 10862 assert(ex == "nan**********************"); 10863 assert(ios.width() == 0); 10864 } 10865 ios.width(25); 10866 right(ios); 10867 { 10868 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10869 std::string ex(str, iter.base()); 10870 assert(ex == "**********************nan"); 10871 assert(ios.width() == 0); 10872 } 10873 ios.width(25); 10874 internal(ios); 10875 { 10876 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10877 std::string ex(str, iter.base()); 10878 assert(ex == "**********************nan"); 10879 assert(ios.width() == 0); 10880 } 10881 } 10882 } 10883 } 10884 showpos(ios); 10885 { 10886 noshowpoint(ios); 10887 { 10888 ios.imbue(lc); 10889 { 10890 ios.width(0); 10891 { 10892 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10893 std::string ex(str, iter.base()); 10894 assert(ex == "nan"); 10895 assert(ios.width() == 0); 10896 } 10897 ios.width(25); 10898 left(ios); 10899 { 10900 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10901 std::string ex(str, iter.base()); 10902 assert(ex == "nan**********************"); 10903 assert(ios.width() == 0); 10904 } 10905 ios.width(25); 10906 right(ios); 10907 { 10908 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10909 std::string ex(str, iter.base()); 10910 assert(ex == "**********************nan"); 10911 assert(ios.width() == 0); 10912 } 10913 ios.width(25); 10914 internal(ios); 10915 { 10916 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10917 std::string ex(str, iter.base()); 10918 assert(ex == "**********************nan"); 10919 assert(ios.width() == 0); 10920 } 10921 } 10922 ios.imbue(lg); 10923 { 10924 ios.width(0); 10925 { 10926 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10927 std::string ex(str, iter.base()); 10928 assert(ex == "nan"); 10929 assert(ios.width() == 0); 10930 } 10931 ios.width(25); 10932 left(ios); 10933 { 10934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10935 std::string ex(str, iter.base()); 10936 assert(ex == "nan**********************"); 10937 assert(ios.width() == 0); 10938 } 10939 ios.width(25); 10940 right(ios); 10941 { 10942 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10943 std::string ex(str, iter.base()); 10944 assert(ex == "**********************nan"); 10945 assert(ios.width() == 0); 10946 } 10947 ios.width(25); 10948 internal(ios); 10949 { 10950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10951 std::string ex(str, iter.base()); 10952 assert(ex == "**********************nan"); 10953 assert(ios.width() == 0); 10954 } 10955 } 10956 } 10957 showpoint(ios); 10958 { 10959 ios.imbue(lc); 10960 { 10961 ios.width(0); 10962 { 10963 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10964 std::string ex(str, iter.base()); 10965 assert(ex == "nan"); 10966 assert(ios.width() == 0); 10967 } 10968 ios.width(25); 10969 left(ios); 10970 { 10971 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10972 std::string ex(str, iter.base()); 10973 assert(ex == "nan**********************"); 10974 assert(ios.width() == 0); 10975 } 10976 ios.width(25); 10977 right(ios); 10978 { 10979 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10980 std::string ex(str, iter.base()); 10981 assert(ex == "**********************nan"); 10982 assert(ios.width() == 0); 10983 } 10984 ios.width(25); 10985 internal(ios); 10986 { 10987 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10988 std::string ex(str, iter.base()); 10989 assert(ex == "**********************nan"); 10990 assert(ios.width() == 0); 10991 } 10992 } 10993 ios.imbue(lg); 10994 { 10995 ios.width(0); 10996 { 10997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10998 std::string ex(str, iter.base()); 10999 assert(ex == "nan"); 11000 assert(ios.width() == 0); 11001 } 11002 ios.width(25); 11003 left(ios); 11004 { 11005 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11006 std::string ex(str, iter.base()); 11007 assert(ex == "nan**********************"); 11008 assert(ios.width() == 0); 11009 } 11010 ios.width(25); 11011 right(ios); 11012 { 11013 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11014 std::string ex(str, iter.base()); 11015 assert(ex == "**********************nan"); 11016 assert(ios.width() == 0); 11017 } 11018 ios.width(25); 11019 internal(ios); 11020 { 11021 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11022 std::string ex(str, iter.base()); 11023 assert(ex == "**********************nan"); 11024 assert(ios.width() == 0); 11025 } 11026 } 11027 } 11028 } 11029 } 11030 uppercase(ios); 11031 { 11032 noshowpos(ios); 11033 { 11034 noshowpoint(ios); 11035 { 11036 ios.imbue(lc); 11037 { 11038 ios.width(0); 11039 { 11040 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11041 std::string ex(str, iter.base()); 11042 assert(ex == "NAN"); 11043 assert(ios.width() == 0); 11044 } 11045 ios.width(25); 11046 left(ios); 11047 { 11048 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11049 std::string ex(str, iter.base()); 11050 assert(ex == "NAN**********************"); 11051 assert(ios.width() == 0); 11052 } 11053 ios.width(25); 11054 right(ios); 11055 { 11056 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11057 std::string ex(str, iter.base()); 11058 assert(ex == "**********************NAN"); 11059 assert(ios.width() == 0); 11060 } 11061 ios.width(25); 11062 internal(ios); 11063 { 11064 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11065 std::string ex(str, iter.base()); 11066 assert(ex == "**********************NAN"); 11067 assert(ios.width() == 0); 11068 } 11069 } 11070 ios.imbue(lg); 11071 { 11072 ios.width(0); 11073 { 11074 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11075 std::string ex(str, iter.base()); 11076 assert(ex == "NAN"); 11077 assert(ios.width() == 0); 11078 } 11079 ios.width(25); 11080 left(ios); 11081 { 11082 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11083 std::string ex(str, iter.base()); 11084 assert(ex == "NAN**********************"); 11085 assert(ios.width() == 0); 11086 } 11087 ios.width(25); 11088 right(ios); 11089 { 11090 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11091 std::string ex(str, iter.base()); 11092 assert(ex == "**********************NAN"); 11093 assert(ios.width() == 0); 11094 } 11095 ios.width(25); 11096 internal(ios); 11097 { 11098 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11099 std::string ex(str, iter.base()); 11100 assert(ex == "**********************NAN"); 11101 assert(ios.width() == 0); 11102 } 11103 } 11104 } 11105 showpoint(ios); 11106 { 11107 ios.imbue(lc); 11108 { 11109 ios.width(0); 11110 { 11111 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11112 std::string ex(str, iter.base()); 11113 assert(ex == "NAN"); 11114 assert(ios.width() == 0); 11115 } 11116 ios.width(25); 11117 left(ios); 11118 { 11119 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11120 std::string ex(str, iter.base()); 11121 assert(ex == "NAN**********************"); 11122 assert(ios.width() == 0); 11123 } 11124 ios.width(25); 11125 right(ios); 11126 { 11127 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11128 std::string ex(str, iter.base()); 11129 assert(ex == "**********************NAN"); 11130 assert(ios.width() == 0); 11131 } 11132 ios.width(25); 11133 internal(ios); 11134 { 11135 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11136 std::string ex(str, iter.base()); 11137 assert(ex == "**********************NAN"); 11138 assert(ios.width() == 0); 11139 } 11140 } 11141 ios.imbue(lg); 11142 { 11143 ios.width(0); 11144 { 11145 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11146 std::string ex(str, iter.base()); 11147 assert(ex == "NAN"); 11148 assert(ios.width() == 0); 11149 } 11150 ios.width(25); 11151 left(ios); 11152 { 11153 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11154 std::string ex(str, iter.base()); 11155 assert(ex == "NAN**********************"); 11156 assert(ios.width() == 0); 11157 } 11158 ios.width(25); 11159 right(ios); 11160 { 11161 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11162 std::string ex(str, iter.base()); 11163 assert(ex == "**********************NAN"); 11164 assert(ios.width() == 0); 11165 } 11166 ios.width(25); 11167 internal(ios); 11168 { 11169 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11170 std::string ex(str, iter.base()); 11171 assert(ex == "**********************NAN"); 11172 assert(ios.width() == 0); 11173 } 11174 } 11175 } 11176 } 11177 showpos(ios); 11178 { 11179 noshowpoint(ios); 11180 { 11181 ios.imbue(lc); 11182 { 11183 ios.width(0); 11184 { 11185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11186 std::string ex(str, iter.base()); 11187 assert(ex == "NAN"); 11188 assert(ios.width() == 0); 11189 } 11190 ios.width(25); 11191 left(ios); 11192 { 11193 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11194 std::string ex(str, iter.base()); 11195 assert(ex == "NAN**********************"); 11196 assert(ios.width() == 0); 11197 } 11198 ios.width(25); 11199 right(ios); 11200 { 11201 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11202 std::string ex(str, iter.base()); 11203 assert(ex == "**********************NAN"); 11204 assert(ios.width() == 0); 11205 } 11206 ios.width(25); 11207 internal(ios); 11208 { 11209 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11210 std::string ex(str, iter.base()); 11211 assert(ex == "**********************NAN"); 11212 assert(ios.width() == 0); 11213 } 11214 } 11215 ios.imbue(lg); 11216 { 11217 ios.width(0); 11218 { 11219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11220 std::string ex(str, iter.base()); 11221 assert(ex == "NAN"); 11222 assert(ios.width() == 0); 11223 } 11224 ios.width(25); 11225 left(ios); 11226 { 11227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11228 std::string ex(str, iter.base()); 11229 assert(ex == "NAN**********************"); 11230 assert(ios.width() == 0); 11231 } 11232 ios.width(25); 11233 right(ios); 11234 { 11235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11236 std::string ex(str, iter.base()); 11237 assert(ex == "**********************NAN"); 11238 assert(ios.width() == 0); 11239 } 11240 ios.width(25); 11241 internal(ios); 11242 { 11243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11244 std::string ex(str, iter.base()); 11245 assert(ex == "**********************NAN"); 11246 assert(ios.width() == 0); 11247 } 11248 } 11249 } 11250 showpoint(ios); 11251 { 11252 ios.imbue(lc); 11253 { 11254 ios.width(0); 11255 { 11256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11257 std::string ex(str, iter.base()); 11258 assert(ex == "NAN"); 11259 assert(ios.width() == 0); 11260 } 11261 ios.width(25); 11262 left(ios); 11263 { 11264 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11265 std::string ex(str, iter.base()); 11266 assert(ex == "NAN**********************"); 11267 assert(ios.width() == 0); 11268 } 11269 ios.width(25); 11270 right(ios); 11271 { 11272 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11273 std::string ex(str, iter.base()); 11274 assert(ex == "**********************NAN"); 11275 assert(ios.width() == 0); 11276 } 11277 ios.width(25); 11278 internal(ios); 11279 { 11280 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11281 std::string ex(str, iter.base()); 11282 assert(ex == "**********************NAN"); 11283 assert(ios.width() == 0); 11284 } 11285 } 11286 ios.imbue(lg); 11287 { 11288 ios.width(0); 11289 { 11290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11291 std::string ex(str, iter.base()); 11292 assert(ex == "NAN"); 11293 assert(ios.width() == 0); 11294 } 11295 ios.width(25); 11296 left(ios); 11297 { 11298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11299 std::string ex(str, iter.base()); 11300 assert(ex == "NAN**********************"); 11301 assert(ios.width() == 0); 11302 } 11303 ios.width(25); 11304 right(ios); 11305 { 11306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11307 std::string ex(str, iter.base()); 11308 assert(ex == "**********************NAN"); 11309 assert(ios.width() == 0); 11310 } 11311 ios.width(25); 11312 internal(ios); 11313 { 11314 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11315 std::string ex(str, iter.base()); 11316 assert(ex == "**********************NAN"); 11317 assert(ios.width() == 0); 11318 } 11319 } 11320 } 11321 } 11322 } 11323 } 11324 ios.precision(1); 11325 {} 11326 ios.precision(6); 11327 {} 11328 ios.precision(16); 11329 {} 11330 ios.precision(60); 11331 {} 11332 } 11333 } 11334 } 11335 11336 void test6() 11337 { 11338 char str[200]; 11339 output_iterator<char*> iter; 11340 std::locale lc = std::locale::classic(); 11341 std::locale lg(lc, new my_numpunct); 11342 const my_facet f(1); 11343 { 11344 long double v = +0.; 11345 std::ios ios(0); 11346 fixed(ios); 11347 // %f 11348 { 11349 ios.precision(0); 11350 { 11351 nouppercase(ios); 11352 { 11353 noshowpos(ios); 11354 { 11355 noshowpoint(ios); 11356 { 11357 ios.imbue(lc); 11358 { 11359 ios.width(0); 11360 { 11361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11362 std::string ex(str, iter.base()); 11363 assert(ex == "0"); 11364 assert(ios.width() == 0); 11365 } 11366 ios.width(25); 11367 left(ios); 11368 { 11369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11370 std::string ex(str, iter.base()); 11371 assert(ex == "0************************"); 11372 assert(ios.width() == 0); 11373 } 11374 ios.width(25); 11375 right(ios); 11376 { 11377 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11378 std::string ex(str, iter.base()); 11379 assert(ex == "************************0"); 11380 assert(ios.width() == 0); 11381 } 11382 ios.width(25); 11383 internal(ios); 11384 { 11385 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11386 std::string ex(str, iter.base()); 11387 assert(ex == "************************0"); 11388 assert(ios.width() == 0); 11389 } 11390 } 11391 ios.imbue(lg); 11392 { 11393 ios.width(0); 11394 { 11395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11396 std::string ex(str, iter.base()); 11397 assert(ex == "0"); 11398 assert(ios.width() == 0); 11399 } 11400 ios.width(25); 11401 left(ios); 11402 { 11403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11404 std::string ex(str, iter.base()); 11405 assert(ex == "0************************"); 11406 assert(ios.width() == 0); 11407 } 11408 ios.width(25); 11409 right(ios); 11410 { 11411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11412 std::string ex(str, iter.base()); 11413 assert(ex == "************************0"); 11414 assert(ios.width() == 0); 11415 } 11416 ios.width(25); 11417 internal(ios); 11418 { 11419 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11420 std::string ex(str, iter.base()); 11421 assert(ex == "************************0"); 11422 assert(ios.width() == 0); 11423 } 11424 } 11425 } 11426 showpoint(ios); 11427 { 11428 ios.imbue(lc); 11429 { 11430 ios.width(0); 11431 { 11432 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11433 std::string ex(str, iter.base()); 11434 assert(ex == "0."); 11435 assert(ios.width() == 0); 11436 } 11437 ios.width(25); 11438 left(ios); 11439 { 11440 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11441 std::string ex(str, iter.base()); 11442 assert(ex == "0.***********************"); 11443 assert(ios.width() == 0); 11444 } 11445 ios.width(25); 11446 right(ios); 11447 { 11448 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11449 std::string ex(str, iter.base()); 11450 assert(ex == "***********************0."); 11451 assert(ios.width() == 0); 11452 } 11453 ios.width(25); 11454 internal(ios); 11455 { 11456 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11457 std::string ex(str, iter.base()); 11458 assert(ex == "***********************0."); 11459 assert(ios.width() == 0); 11460 } 11461 } 11462 ios.imbue(lg); 11463 { 11464 ios.width(0); 11465 { 11466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11467 std::string ex(str, iter.base()); 11468 assert(ex == "0;"); 11469 assert(ios.width() == 0); 11470 } 11471 ios.width(25); 11472 left(ios); 11473 { 11474 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11475 std::string ex(str, iter.base()); 11476 assert(ex == "0;***********************"); 11477 assert(ios.width() == 0); 11478 } 11479 ios.width(25); 11480 right(ios); 11481 { 11482 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11483 std::string ex(str, iter.base()); 11484 assert(ex == "***********************0;"); 11485 assert(ios.width() == 0); 11486 } 11487 ios.width(25); 11488 internal(ios); 11489 { 11490 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11491 std::string ex(str, iter.base()); 11492 assert(ex == "***********************0;"); 11493 assert(ios.width() == 0); 11494 } 11495 } 11496 } 11497 } 11498 showpos(ios); 11499 { 11500 noshowpoint(ios); 11501 { 11502 ios.imbue(lc); 11503 { 11504 ios.width(0); 11505 { 11506 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11507 std::string ex(str, iter.base()); 11508 assert(ex == "+0"); 11509 assert(ios.width() == 0); 11510 } 11511 ios.width(25); 11512 left(ios); 11513 { 11514 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11515 std::string ex(str, iter.base()); 11516 assert(ex == "+0***********************"); 11517 assert(ios.width() == 0); 11518 } 11519 ios.width(25); 11520 right(ios); 11521 { 11522 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11523 std::string ex(str, iter.base()); 11524 assert(ex == "***********************+0"); 11525 assert(ios.width() == 0); 11526 } 11527 ios.width(25); 11528 internal(ios); 11529 { 11530 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11531 std::string ex(str, iter.base()); 11532 assert(ex == "+***********************0"); 11533 assert(ios.width() == 0); 11534 } 11535 } 11536 ios.imbue(lg); 11537 { 11538 ios.width(0); 11539 { 11540 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11541 std::string ex(str, iter.base()); 11542 assert(ex == "+0"); 11543 assert(ios.width() == 0); 11544 } 11545 ios.width(25); 11546 left(ios); 11547 { 11548 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11549 std::string ex(str, iter.base()); 11550 assert(ex == "+0***********************"); 11551 assert(ios.width() == 0); 11552 } 11553 ios.width(25); 11554 right(ios); 11555 { 11556 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11557 std::string ex(str, iter.base()); 11558 assert(ex == "***********************+0"); 11559 assert(ios.width() == 0); 11560 } 11561 ios.width(25); 11562 internal(ios); 11563 { 11564 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11565 std::string ex(str, iter.base()); 11566 assert(ex == "+***********************0"); 11567 assert(ios.width() == 0); 11568 } 11569 } 11570 } 11571 showpoint(ios); 11572 { 11573 ios.imbue(lc); 11574 { 11575 ios.width(0); 11576 { 11577 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11578 std::string ex(str, iter.base()); 11579 assert(ex == "+0."); 11580 assert(ios.width() == 0); 11581 } 11582 ios.width(25); 11583 left(ios); 11584 { 11585 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11586 std::string ex(str, iter.base()); 11587 assert(ex == "+0.**********************"); 11588 assert(ios.width() == 0); 11589 } 11590 ios.width(25); 11591 right(ios); 11592 { 11593 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11594 std::string ex(str, iter.base()); 11595 assert(ex == "**********************+0."); 11596 assert(ios.width() == 0); 11597 } 11598 ios.width(25); 11599 internal(ios); 11600 { 11601 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11602 std::string ex(str, iter.base()); 11603 assert(ex == "+**********************0."); 11604 assert(ios.width() == 0); 11605 } 11606 } 11607 ios.imbue(lg); 11608 { 11609 ios.width(0); 11610 { 11611 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11612 std::string ex(str, iter.base()); 11613 assert(ex == "+0;"); 11614 assert(ios.width() == 0); 11615 } 11616 ios.width(25); 11617 left(ios); 11618 { 11619 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11620 std::string ex(str, iter.base()); 11621 assert(ex == "+0;**********************"); 11622 assert(ios.width() == 0); 11623 } 11624 ios.width(25); 11625 right(ios); 11626 { 11627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11628 std::string ex(str, iter.base()); 11629 assert(ex == "**********************+0;"); 11630 assert(ios.width() == 0); 11631 } 11632 ios.width(25); 11633 internal(ios); 11634 { 11635 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11636 std::string ex(str, iter.base()); 11637 assert(ex == "+**********************0;"); 11638 assert(ios.width() == 0); 11639 } 11640 } 11641 } 11642 } 11643 } 11644 uppercase(ios); 11645 { 11646 noshowpos(ios); 11647 { 11648 noshowpoint(ios); 11649 { 11650 ios.imbue(lc); 11651 { 11652 ios.width(0); 11653 { 11654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11655 std::string ex(str, iter.base()); 11656 assert(ex == "0"); 11657 assert(ios.width() == 0); 11658 } 11659 ios.width(25); 11660 left(ios); 11661 { 11662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11663 std::string ex(str, iter.base()); 11664 assert(ex == "0************************"); 11665 assert(ios.width() == 0); 11666 } 11667 ios.width(25); 11668 right(ios); 11669 { 11670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11671 std::string ex(str, iter.base()); 11672 assert(ex == "************************0"); 11673 assert(ios.width() == 0); 11674 } 11675 ios.width(25); 11676 internal(ios); 11677 { 11678 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11679 std::string ex(str, iter.base()); 11680 assert(ex == "************************0"); 11681 assert(ios.width() == 0); 11682 } 11683 } 11684 ios.imbue(lg); 11685 { 11686 ios.width(0); 11687 { 11688 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11689 std::string ex(str, iter.base()); 11690 assert(ex == "0"); 11691 assert(ios.width() == 0); 11692 } 11693 ios.width(25); 11694 left(ios); 11695 { 11696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11697 std::string ex(str, iter.base()); 11698 assert(ex == "0************************"); 11699 assert(ios.width() == 0); 11700 } 11701 ios.width(25); 11702 right(ios); 11703 { 11704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11705 std::string ex(str, iter.base()); 11706 assert(ex == "************************0"); 11707 assert(ios.width() == 0); 11708 } 11709 ios.width(25); 11710 internal(ios); 11711 { 11712 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11713 std::string ex(str, iter.base()); 11714 assert(ex == "************************0"); 11715 assert(ios.width() == 0); 11716 } 11717 } 11718 } 11719 showpoint(ios); 11720 { 11721 ios.imbue(lc); 11722 { 11723 ios.width(0); 11724 { 11725 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11726 std::string ex(str, iter.base()); 11727 assert(ex == "0."); 11728 assert(ios.width() == 0); 11729 } 11730 ios.width(25); 11731 left(ios); 11732 { 11733 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11734 std::string ex(str, iter.base()); 11735 assert(ex == "0.***********************"); 11736 assert(ios.width() == 0); 11737 } 11738 ios.width(25); 11739 right(ios); 11740 { 11741 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11742 std::string ex(str, iter.base()); 11743 assert(ex == "***********************0."); 11744 assert(ios.width() == 0); 11745 } 11746 ios.width(25); 11747 internal(ios); 11748 { 11749 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11750 std::string ex(str, iter.base()); 11751 assert(ex == "***********************0."); 11752 assert(ios.width() == 0); 11753 } 11754 } 11755 ios.imbue(lg); 11756 { 11757 ios.width(0); 11758 { 11759 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11760 std::string ex(str, iter.base()); 11761 assert(ex == "0;"); 11762 assert(ios.width() == 0); 11763 } 11764 ios.width(25); 11765 left(ios); 11766 { 11767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11768 std::string ex(str, iter.base()); 11769 assert(ex == "0;***********************"); 11770 assert(ios.width() == 0); 11771 } 11772 ios.width(25); 11773 right(ios); 11774 { 11775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11776 std::string ex(str, iter.base()); 11777 assert(ex == "***********************0;"); 11778 assert(ios.width() == 0); 11779 } 11780 ios.width(25); 11781 internal(ios); 11782 { 11783 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11784 std::string ex(str, iter.base()); 11785 assert(ex == "***********************0;"); 11786 assert(ios.width() == 0); 11787 } 11788 } 11789 } 11790 } 11791 showpos(ios); 11792 { 11793 noshowpoint(ios); 11794 { 11795 ios.imbue(lc); 11796 { 11797 ios.width(0); 11798 { 11799 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11800 std::string ex(str, iter.base()); 11801 assert(ex == "+0"); 11802 assert(ios.width() == 0); 11803 } 11804 ios.width(25); 11805 left(ios); 11806 { 11807 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11808 std::string ex(str, iter.base()); 11809 assert(ex == "+0***********************"); 11810 assert(ios.width() == 0); 11811 } 11812 ios.width(25); 11813 right(ios); 11814 { 11815 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11816 std::string ex(str, iter.base()); 11817 assert(ex == "***********************+0"); 11818 assert(ios.width() == 0); 11819 } 11820 ios.width(25); 11821 internal(ios); 11822 { 11823 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11824 std::string ex(str, iter.base()); 11825 assert(ex == "+***********************0"); 11826 assert(ios.width() == 0); 11827 } 11828 } 11829 ios.imbue(lg); 11830 { 11831 ios.width(0); 11832 { 11833 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11834 std::string ex(str, iter.base()); 11835 assert(ex == "+0"); 11836 assert(ios.width() == 0); 11837 } 11838 ios.width(25); 11839 left(ios); 11840 { 11841 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11842 std::string ex(str, iter.base()); 11843 assert(ex == "+0***********************"); 11844 assert(ios.width() == 0); 11845 } 11846 ios.width(25); 11847 right(ios); 11848 { 11849 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11850 std::string ex(str, iter.base()); 11851 assert(ex == "***********************+0"); 11852 assert(ios.width() == 0); 11853 } 11854 ios.width(25); 11855 internal(ios); 11856 { 11857 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11858 std::string ex(str, iter.base()); 11859 assert(ex == "+***********************0"); 11860 assert(ios.width() == 0); 11861 } 11862 } 11863 } 11864 showpoint(ios); 11865 { 11866 ios.imbue(lc); 11867 { 11868 ios.width(0); 11869 { 11870 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11871 std::string ex(str, iter.base()); 11872 assert(ex == "+0."); 11873 assert(ios.width() == 0); 11874 } 11875 ios.width(25); 11876 left(ios); 11877 { 11878 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11879 std::string ex(str, iter.base()); 11880 assert(ex == "+0.**********************"); 11881 assert(ios.width() == 0); 11882 } 11883 ios.width(25); 11884 right(ios); 11885 { 11886 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11887 std::string ex(str, iter.base()); 11888 assert(ex == "**********************+0."); 11889 assert(ios.width() == 0); 11890 } 11891 ios.width(25); 11892 internal(ios); 11893 { 11894 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11895 std::string ex(str, iter.base()); 11896 assert(ex == "+**********************0."); 11897 assert(ios.width() == 0); 11898 } 11899 } 11900 ios.imbue(lg); 11901 { 11902 ios.width(0); 11903 { 11904 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11905 std::string ex(str, iter.base()); 11906 assert(ex == "+0;"); 11907 assert(ios.width() == 0); 11908 } 11909 ios.width(25); 11910 left(ios); 11911 { 11912 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11913 std::string ex(str, iter.base()); 11914 assert(ex == "+0;**********************"); 11915 assert(ios.width() == 0); 11916 } 11917 ios.width(25); 11918 right(ios); 11919 { 11920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11921 std::string ex(str, iter.base()); 11922 assert(ex == "**********************+0;"); 11923 assert(ios.width() == 0); 11924 } 11925 ios.width(25); 11926 internal(ios); 11927 { 11928 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11929 std::string ex(str, iter.base()); 11930 assert(ex == "+**********************0;"); 11931 assert(ios.width() == 0); 11932 } 11933 } 11934 } 11935 } 11936 } 11937 } 11938 ios.precision(1); 11939 { 11940 nouppercase(ios); 11941 { 11942 noshowpos(ios); 11943 { 11944 noshowpoint(ios); 11945 { 11946 ios.imbue(lc); 11947 { 11948 ios.width(0); 11949 { 11950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11951 std::string ex(str, iter.base()); 11952 assert(ex == "0.0"); 11953 assert(ios.width() == 0); 11954 } 11955 ios.width(25); 11956 left(ios); 11957 { 11958 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11959 std::string ex(str, iter.base()); 11960 assert(ex == "0.0**********************"); 11961 assert(ios.width() == 0); 11962 } 11963 ios.width(25); 11964 right(ios); 11965 { 11966 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11967 std::string ex(str, iter.base()); 11968 assert(ex == "**********************0.0"); 11969 assert(ios.width() == 0); 11970 } 11971 ios.width(25); 11972 internal(ios); 11973 { 11974 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11975 std::string ex(str, iter.base()); 11976 assert(ex == "**********************0.0"); 11977 assert(ios.width() == 0); 11978 } 11979 } 11980 ios.imbue(lg); 11981 { 11982 ios.width(0); 11983 { 11984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11985 std::string ex(str, iter.base()); 11986 assert(ex == "0;0"); 11987 assert(ios.width() == 0); 11988 } 11989 ios.width(25); 11990 left(ios); 11991 { 11992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11993 std::string ex(str, iter.base()); 11994 assert(ex == "0;0**********************"); 11995 assert(ios.width() == 0); 11996 } 11997 ios.width(25); 11998 right(ios); 11999 { 12000 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12001 std::string ex(str, iter.base()); 12002 assert(ex == "**********************0;0"); 12003 assert(ios.width() == 0); 12004 } 12005 ios.width(25); 12006 internal(ios); 12007 { 12008 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12009 std::string ex(str, iter.base()); 12010 assert(ex == "**********************0;0"); 12011 assert(ios.width() == 0); 12012 } 12013 } 12014 } 12015 showpoint(ios); 12016 { 12017 ios.imbue(lc); 12018 { 12019 ios.width(0); 12020 { 12021 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12022 std::string ex(str, iter.base()); 12023 assert(ex == "0.0"); 12024 assert(ios.width() == 0); 12025 } 12026 ios.width(25); 12027 left(ios); 12028 { 12029 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12030 std::string ex(str, iter.base()); 12031 assert(ex == "0.0**********************"); 12032 assert(ios.width() == 0); 12033 } 12034 ios.width(25); 12035 right(ios); 12036 { 12037 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12038 std::string ex(str, iter.base()); 12039 assert(ex == "**********************0.0"); 12040 assert(ios.width() == 0); 12041 } 12042 ios.width(25); 12043 internal(ios); 12044 { 12045 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12046 std::string ex(str, iter.base()); 12047 assert(ex == "**********************0.0"); 12048 assert(ios.width() == 0); 12049 } 12050 } 12051 ios.imbue(lg); 12052 { 12053 ios.width(0); 12054 { 12055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12056 std::string ex(str, iter.base()); 12057 assert(ex == "0;0"); 12058 assert(ios.width() == 0); 12059 } 12060 ios.width(25); 12061 left(ios); 12062 { 12063 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12064 std::string ex(str, iter.base()); 12065 assert(ex == "0;0**********************"); 12066 assert(ios.width() == 0); 12067 } 12068 ios.width(25); 12069 right(ios); 12070 { 12071 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12072 std::string ex(str, iter.base()); 12073 assert(ex == "**********************0;0"); 12074 assert(ios.width() == 0); 12075 } 12076 ios.width(25); 12077 internal(ios); 12078 { 12079 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12080 std::string ex(str, iter.base()); 12081 assert(ex == "**********************0;0"); 12082 assert(ios.width() == 0); 12083 } 12084 } 12085 } 12086 } 12087 showpos(ios); 12088 { 12089 noshowpoint(ios); 12090 { 12091 ios.imbue(lc); 12092 { 12093 ios.width(0); 12094 { 12095 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12096 std::string ex(str, iter.base()); 12097 assert(ex == "+0.0"); 12098 assert(ios.width() == 0); 12099 } 12100 ios.width(25); 12101 left(ios); 12102 { 12103 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12104 std::string ex(str, iter.base()); 12105 assert(ex == "+0.0*********************"); 12106 assert(ios.width() == 0); 12107 } 12108 ios.width(25); 12109 right(ios); 12110 { 12111 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12112 std::string ex(str, iter.base()); 12113 assert(ex == "*********************+0.0"); 12114 assert(ios.width() == 0); 12115 } 12116 ios.width(25); 12117 internal(ios); 12118 { 12119 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12120 std::string ex(str, iter.base()); 12121 assert(ex == "+*********************0.0"); 12122 assert(ios.width() == 0); 12123 } 12124 } 12125 ios.imbue(lg); 12126 { 12127 ios.width(0); 12128 { 12129 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12130 std::string ex(str, iter.base()); 12131 assert(ex == "+0;0"); 12132 assert(ios.width() == 0); 12133 } 12134 ios.width(25); 12135 left(ios); 12136 { 12137 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12138 std::string ex(str, iter.base()); 12139 assert(ex == "+0;0*********************"); 12140 assert(ios.width() == 0); 12141 } 12142 ios.width(25); 12143 right(ios); 12144 { 12145 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12146 std::string ex(str, iter.base()); 12147 assert(ex == "*********************+0;0"); 12148 assert(ios.width() == 0); 12149 } 12150 ios.width(25); 12151 internal(ios); 12152 { 12153 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12154 std::string ex(str, iter.base()); 12155 assert(ex == "+*********************0;0"); 12156 assert(ios.width() == 0); 12157 } 12158 } 12159 } 12160 showpoint(ios); 12161 { 12162 ios.imbue(lc); 12163 { 12164 ios.width(0); 12165 { 12166 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12167 std::string ex(str, iter.base()); 12168 assert(ex == "+0.0"); 12169 assert(ios.width() == 0); 12170 } 12171 ios.width(25); 12172 left(ios); 12173 { 12174 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12175 std::string ex(str, iter.base()); 12176 assert(ex == "+0.0*********************"); 12177 assert(ios.width() == 0); 12178 } 12179 ios.width(25); 12180 right(ios); 12181 { 12182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12183 std::string ex(str, iter.base()); 12184 assert(ex == "*********************+0.0"); 12185 assert(ios.width() == 0); 12186 } 12187 ios.width(25); 12188 internal(ios); 12189 { 12190 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12191 std::string ex(str, iter.base()); 12192 assert(ex == "+*********************0.0"); 12193 assert(ios.width() == 0); 12194 } 12195 } 12196 ios.imbue(lg); 12197 { 12198 ios.width(0); 12199 { 12200 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12201 std::string ex(str, iter.base()); 12202 assert(ex == "+0;0"); 12203 assert(ios.width() == 0); 12204 } 12205 ios.width(25); 12206 left(ios); 12207 { 12208 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12209 std::string ex(str, iter.base()); 12210 assert(ex == "+0;0*********************"); 12211 assert(ios.width() == 0); 12212 } 12213 ios.width(25); 12214 right(ios); 12215 { 12216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12217 std::string ex(str, iter.base()); 12218 assert(ex == "*********************+0;0"); 12219 assert(ios.width() == 0); 12220 } 12221 ios.width(25); 12222 internal(ios); 12223 { 12224 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12225 std::string ex(str, iter.base()); 12226 assert(ex == "+*********************0;0"); 12227 assert(ios.width() == 0); 12228 } 12229 } 12230 } 12231 } 12232 } 12233 uppercase(ios); 12234 { 12235 noshowpos(ios); 12236 { 12237 noshowpoint(ios); 12238 { 12239 ios.imbue(lc); 12240 { 12241 ios.width(0); 12242 { 12243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12244 std::string ex(str, iter.base()); 12245 assert(ex == "0.0"); 12246 assert(ios.width() == 0); 12247 } 12248 ios.width(25); 12249 left(ios); 12250 { 12251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12252 std::string ex(str, iter.base()); 12253 assert(ex == "0.0**********************"); 12254 assert(ios.width() == 0); 12255 } 12256 ios.width(25); 12257 right(ios); 12258 { 12259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12260 std::string ex(str, iter.base()); 12261 assert(ex == "**********************0.0"); 12262 assert(ios.width() == 0); 12263 } 12264 ios.width(25); 12265 internal(ios); 12266 { 12267 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12268 std::string ex(str, iter.base()); 12269 assert(ex == "**********************0.0"); 12270 assert(ios.width() == 0); 12271 } 12272 } 12273 ios.imbue(lg); 12274 { 12275 ios.width(0); 12276 { 12277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12278 std::string ex(str, iter.base()); 12279 assert(ex == "0;0"); 12280 assert(ios.width() == 0); 12281 } 12282 ios.width(25); 12283 left(ios); 12284 { 12285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12286 std::string ex(str, iter.base()); 12287 assert(ex == "0;0**********************"); 12288 assert(ios.width() == 0); 12289 } 12290 ios.width(25); 12291 right(ios); 12292 { 12293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12294 std::string ex(str, iter.base()); 12295 assert(ex == "**********************0;0"); 12296 assert(ios.width() == 0); 12297 } 12298 ios.width(25); 12299 internal(ios); 12300 { 12301 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12302 std::string ex(str, iter.base()); 12303 assert(ex == "**********************0;0"); 12304 assert(ios.width() == 0); 12305 } 12306 } 12307 } 12308 showpoint(ios); 12309 { 12310 ios.imbue(lc); 12311 { 12312 ios.width(0); 12313 { 12314 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12315 std::string ex(str, iter.base()); 12316 assert(ex == "0.0"); 12317 assert(ios.width() == 0); 12318 } 12319 ios.width(25); 12320 left(ios); 12321 { 12322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12323 std::string ex(str, iter.base()); 12324 assert(ex == "0.0**********************"); 12325 assert(ios.width() == 0); 12326 } 12327 ios.width(25); 12328 right(ios); 12329 { 12330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12331 std::string ex(str, iter.base()); 12332 assert(ex == "**********************0.0"); 12333 assert(ios.width() == 0); 12334 } 12335 ios.width(25); 12336 internal(ios); 12337 { 12338 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12339 std::string ex(str, iter.base()); 12340 assert(ex == "**********************0.0"); 12341 assert(ios.width() == 0); 12342 } 12343 } 12344 ios.imbue(lg); 12345 { 12346 ios.width(0); 12347 { 12348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12349 std::string ex(str, iter.base()); 12350 assert(ex == "0;0"); 12351 assert(ios.width() == 0); 12352 } 12353 ios.width(25); 12354 left(ios); 12355 { 12356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12357 std::string ex(str, iter.base()); 12358 assert(ex == "0;0**********************"); 12359 assert(ios.width() == 0); 12360 } 12361 ios.width(25); 12362 right(ios); 12363 { 12364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12365 std::string ex(str, iter.base()); 12366 assert(ex == "**********************0;0"); 12367 assert(ios.width() == 0); 12368 } 12369 ios.width(25); 12370 internal(ios); 12371 { 12372 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12373 std::string ex(str, iter.base()); 12374 assert(ex == "**********************0;0"); 12375 assert(ios.width() == 0); 12376 } 12377 } 12378 } 12379 } 12380 showpos(ios); 12381 { 12382 noshowpoint(ios); 12383 { 12384 ios.imbue(lc); 12385 { 12386 ios.width(0); 12387 { 12388 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12389 std::string ex(str, iter.base()); 12390 assert(ex == "+0.0"); 12391 assert(ios.width() == 0); 12392 } 12393 ios.width(25); 12394 left(ios); 12395 { 12396 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12397 std::string ex(str, iter.base()); 12398 assert(ex == "+0.0*********************"); 12399 assert(ios.width() == 0); 12400 } 12401 ios.width(25); 12402 right(ios); 12403 { 12404 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12405 std::string ex(str, iter.base()); 12406 assert(ex == "*********************+0.0"); 12407 assert(ios.width() == 0); 12408 } 12409 ios.width(25); 12410 internal(ios); 12411 { 12412 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12413 std::string ex(str, iter.base()); 12414 assert(ex == "+*********************0.0"); 12415 assert(ios.width() == 0); 12416 } 12417 } 12418 ios.imbue(lg); 12419 { 12420 ios.width(0); 12421 { 12422 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12423 std::string ex(str, iter.base()); 12424 assert(ex == "+0;0"); 12425 assert(ios.width() == 0); 12426 } 12427 ios.width(25); 12428 left(ios); 12429 { 12430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12431 std::string ex(str, iter.base()); 12432 assert(ex == "+0;0*********************"); 12433 assert(ios.width() == 0); 12434 } 12435 ios.width(25); 12436 right(ios); 12437 { 12438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12439 std::string ex(str, iter.base()); 12440 assert(ex == "*********************+0;0"); 12441 assert(ios.width() == 0); 12442 } 12443 ios.width(25); 12444 internal(ios); 12445 { 12446 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12447 std::string ex(str, iter.base()); 12448 assert(ex == "+*********************0;0"); 12449 assert(ios.width() == 0); 12450 } 12451 } 12452 } 12453 showpoint(ios); 12454 { 12455 ios.imbue(lc); 12456 { 12457 ios.width(0); 12458 { 12459 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12460 std::string ex(str, iter.base()); 12461 assert(ex == "+0.0"); 12462 assert(ios.width() == 0); 12463 } 12464 ios.width(25); 12465 left(ios); 12466 { 12467 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12468 std::string ex(str, iter.base()); 12469 assert(ex == "+0.0*********************"); 12470 assert(ios.width() == 0); 12471 } 12472 ios.width(25); 12473 right(ios); 12474 { 12475 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12476 std::string ex(str, iter.base()); 12477 assert(ex == "*********************+0.0"); 12478 assert(ios.width() == 0); 12479 } 12480 ios.width(25); 12481 internal(ios); 12482 { 12483 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12484 std::string ex(str, iter.base()); 12485 assert(ex == "+*********************0.0"); 12486 assert(ios.width() == 0); 12487 } 12488 } 12489 ios.imbue(lg); 12490 { 12491 ios.width(0); 12492 { 12493 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12494 std::string ex(str, iter.base()); 12495 assert(ex == "+0;0"); 12496 assert(ios.width() == 0); 12497 } 12498 ios.width(25); 12499 left(ios); 12500 { 12501 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12502 std::string ex(str, iter.base()); 12503 assert(ex == "+0;0*********************"); 12504 assert(ios.width() == 0); 12505 } 12506 ios.width(25); 12507 right(ios); 12508 { 12509 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12510 std::string ex(str, iter.base()); 12511 assert(ex == "*********************+0;0"); 12512 assert(ios.width() == 0); 12513 } 12514 ios.width(25); 12515 internal(ios); 12516 { 12517 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12518 std::string ex(str, iter.base()); 12519 assert(ex == "+*********************0;0"); 12520 assert(ios.width() == 0); 12521 } 12522 } 12523 } 12524 } 12525 } 12526 } 12527 ios.precision(6); 12528 { 12529 nouppercase(ios); 12530 { 12531 noshowpos(ios); 12532 { 12533 noshowpoint(ios); 12534 { 12535 ios.imbue(lc); 12536 { 12537 ios.width(0); 12538 { 12539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12540 std::string ex(str, iter.base()); 12541 assert(ex == "0.000000"); 12542 assert(ios.width() == 0); 12543 } 12544 ios.width(25); 12545 left(ios); 12546 { 12547 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12548 std::string ex(str, iter.base()); 12549 assert(ex == "0.000000*****************"); 12550 assert(ios.width() == 0); 12551 } 12552 ios.width(25); 12553 right(ios); 12554 { 12555 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12556 std::string ex(str, iter.base()); 12557 assert(ex == "*****************0.000000"); 12558 assert(ios.width() == 0); 12559 } 12560 ios.width(25); 12561 internal(ios); 12562 { 12563 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12564 std::string ex(str, iter.base()); 12565 assert(ex == "*****************0.000000"); 12566 assert(ios.width() == 0); 12567 } 12568 } 12569 ios.imbue(lg); 12570 { 12571 ios.width(0); 12572 { 12573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12574 std::string ex(str, iter.base()); 12575 assert(ex == "0;000000"); 12576 assert(ios.width() == 0); 12577 } 12578 ios.width(25); 12579 left(ios); 12580 { 12581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12582 std::string ex(str, iter.base()); 12583 assert(ex == "0;000000*****************"); 12584 assert(ios.width() == 0); 12585 } 12586 ios.width(25); 12587 right(ios); 12588 { 12589 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12590 std::string ex(str, iter.base()); 12591 assert(ex == "*****************0;000000"); 12592 assert(ios.width() == 0); 12593 } 12594 ios.width(25); 12595 internal(ios); 12596 { 12597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12598 std::string ex(str, iter.base()); 12599 assert(ex == "*****************0;000000"); 12600 assert(ios.width() == 0); 12601 } 12602 } 12603 } 12604 showpoint(ios); 12605 { 12606 ios.imbue(lc); 12607 { 12608 ios.width(0); 12609 { 12610 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12611 std::string ex(str, iter.base()); 12612 assert(ex == "0.000000"); 12613 assert(ios.width() == 0); 12614 } 12615 ios.width(25); 12616 left(ios); 12617 { 12618 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12619 std::string ex(str, iter.base()); 12620 assert(ex == "0.000000*****************"); 12621 assert(ios.width() == 0); 12622 } 12623 ios.width(25); 12624 right(ios); 12625 { 12626 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12627 std::string ex(str, iter.base()); 12628 assert(ex == "*****************0.000000"); 12629 assert(ios.width() == 0); 12630 } 12631 ios.width(25); 12632 internal(ios); 12633 { 12634 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12635 std::string ex(str, iter.base()); 12636 assert(ex == "*****************0.000000"); 12637 assert(ios.width() == 0); 12638 } 12639 } 12640 ios.imbue(lg); 12641 { 12642 ios.width(0); 12643 { 12644 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12645 std::string ex(str, iter.base()); 12646 assert(ex == "0;000000"); 12647 assert(ios.width() == 0); 12648 } 12649 ios.width(25); 12650 left(ios); 12651 { 12652 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12653 std::string ex(str, iter.base()); 12654 assert(ex == "0;000000*****************"); 12655 assert(ios.width() == 0); 12656 } 12657 ios.width(25); 12658 right(ios); 12659 { 12660 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12661 std::string ex(str, iter.base()); 12662 assert(ex == "*****************0;000000"); 12663 assert(ios.width() == 0); 12664 } 12665 ios.width(25); 12666 internal(ios); 12667 { 12668 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12669 std::string ex(str, iter.base()); 12670 assert(ex == "*****************0;000000"); 12671 assert(ios.width() == 0); 12672 } 12673 } 12674 } 12675 } 12676 showpos(ios); 12677 { 12678 noshowpoint(ios); 12679 { 12680 ios.imbue(lc); 12681 { 12682 ios.width(0); 12683 { 12684 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12685 std::string ex(str, iter.base()); 12686 assert(ex == "+0.000000"); 12687 assert(ios.width() == 0); 12688 } 12689 ios.width(25); 12690 left(ios); 12691 { 12692 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12693 std::string ex(str, iter.base()); 12694 assert(ex == "+0.000000****************"); 12695 assert(ios.width() == 0); 12696 } 12697 ios.width(25); 12698 right(ios); 12699 { 12700 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12701 std::string ex(str, iter.base()); 12702 assert(ex == "****************+0.000000"); 12703 assert(ios.width() == 0); 12704 } 12705 ios.width(25); 12706 internal(ios); 12707 { 12708 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12709 std::string ex(str, iter.base()); 12710 assert(ex == "+****************0.000000"); 12711 assert(ios.width() == 0); 12712 } 12713 } 12714 ios.imbue(lg); 12715 { 12716 ios.width(0); 12717 { 12718 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12719 std::string ex(str, iter.base()); 12720 assert(ex == "+0;000000"); 12721 assert(ios.width() == 0); 12722 } 12723 ios.width(25); 12724 left(ios); 12725 { 12726 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12727 std::string ex(str, iter.base()); 12728 assert(ex == "+0;000000****************"); 12729 assert(ios.width() == 0); 12730 } 12731 ios.width(25); 12732 right(ios); 12733 { 12734 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12735 std::string ex(str, iter.base()); 12736 assert(ex == "****************+0;000000"); 12737 assert(ios.width() == 0); 12738 } 12739 ios.width(25); 12740 internal(ios); 12741 { 12742 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12743 std::string ex(str, iter.base()); 12744 assert(ex == "+****************0;000000"); 12745 assert(ios.width() == 0); 12746 } 12747 } 12748 } 12749 showpoint(ios); 12750 { 12751 ios.imbue(lc); 12752 { 12753 ios.width(0); 12754 { 12755 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12756 std::string ex(str, iter.base()); 12757 assert(ex == "+0.000000"); 12758 assert(ios.width() == 0); 12759 } 12760 ios.width(25); 12761 left(ios); 12762 { 12763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12764 std::string ex(str, iter.base()); 12765 assert(ex == "+0.000000****************"); 12766 assert(ios.width() == 0); 12767 } 12768 ios.width(25); 12769 right(ios); 12770 { 12771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12772 std::string ex(str, iter.base()); 12773 assert(ex == "****************+0.000000"); 12774 assert(ios.width() == 0); 12775 } 12776 ios.width(25); 12777 internal(ios); 12778 { 12779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12780 std::string ex(str, iter.base()); 12781 assert(ex == "+****************0.000000"); 12782 assert(ios.width() == 0); 12783 } 12784 } 12785 ios.imbue(lg); 12786 { 12787 ios.width(0); 12788 { 12789 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12790 std::string ex(str, iter.base()); 12791 assert(ex == "+0;000000"); 12792 assert(ios.width() == 0); 12793 } 12794 ios.width(25); 12795 left(ios); 12796 { 12797 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12798 std::string ex(str, iter.base()); 12799 assert(ex == "+0;000000****************"); 12800 assert(ios.width() == 0); 12801 } 12802 ios.width(25); 12803 right(ios); 12804 { 12805 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12806 std::string ex(str, iter.base()); 12807 assert(ex == "****************+0;000000"); 12808 assert(ios.width() == 0); 12809 } 12810 ios.width(25); 12811 internal(ios); 12812 { 12813 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12814 std::string ex(str, iter.base()); 12815 assert(ex == "+****************0;000000"); 12816 assert(ios.width() == 0); 12817 } 12818 } 12819 } 12820 } 12821 } 12822 uppercase(ios); 12823 { 12824 noshowpos(ios); 12825 { 12826 noshowpoint(ios); 12827 { 12828 ios.imbue(lc); 12829 { 12830 ios.width(0); 12831 { 12832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12833 std::string ex(str, iter.base()); 12834 assert(ex == "0.000000"); 12835 assert(ios.width() == 0); 12836 } 12837 ios.width(25); 12838 left(ios); 12839 { 12840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12841 std::string ex(str, iter.base()); 12842 assert(ex == "0.000000*****************"); 12843 assert(ios.width() == 0); 12844 } 12845 ios.width(25); 12846 right(ios); 12847 { 12848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12849 std::string ex(str, iter.base()); 12850 assert(ex == "*****************0.000000"); 12851 assert(ios.width() == 0); 12852 } 12853 ios.width(25); 12854 internal(ios); 12855 { 12856 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12857 std::string ex(str, iter.base()); 12858 assert(ex == "*****************0.000000"); 12859 assert(ios.width() == 0); 12860 } 12861 } 12862 ios.imbue(lg); 12863 { 12864 ios.width(0); 12865 { 12866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12867 std::string ex(str, iter.base()); 12868 assert(ex == "0;000000"); 12869 assert(ios.width() == 0); 12870 } 12871 ios.width(25); 12872 left(ios); 12873 { 12874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12875 std::string ex(str, iter.base()); 12876 assert(ex == "0;000000*****************"); 12877 assert(ios.width() == 0); 12878 } 12879 ios.width(25); 12880 right(ios); 12881 { 12882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12883 std::string ex(str, iter.base()); 12884 assert(ex == "*****************0;000000"); 12885 assert(ios.width() == 0); 12886 } 12887 ios.width(25); 12888 internal(ios); 12889 { 12890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12891 std::string ex(str, iter.base()); 12892 assert(ex == "*****************0;000000"); 12893 assert(ios.width() == 0); 12894 } 12895 } 12896 } 12897 showpoint(ios); 12898 { 12899 ios.imbue(lc); 12900 { 12901 ios.width(0); 12902 { 12903 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12904 std::string ex(str, iter.base()); 12905 assert(ex == "0.000000"); 12906 assert(ios.width() == 0); 12907 } 12908 ios.width(25); 12909 left(ios); 12910 { 12911 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12912 std::string ex(str, iter.base()); 12913 assert(ex == "0.000000*****************"); 12914 assert(ios.width() == 0); 12915 } 12916 ios.width(25); 12917 right(ios); 12918 { 12919 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12920 std::string ex(str, iter.base()); 12921 assert(ex == "*****************0.000000"); 12922 assert(ios.width() == 0); 12923 } 12924 ios.width(25); 12925 internal(ios); 12926 { 12927 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12928 std::string ex(str, iter.base()); 12929 assert(ex == "*****************0.000000"); 12930 assert(ios.width() == 0); 12931 } 12932 } 12933 ios.imbue(lg); 12934 { 12935 ios.width(0); 12936 { 12937 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12938 std::string ex(str, iter.base()); 12939 assert(ex == "0;000000"); 12940 assert(ios.width() == 0); 12941 } 12942 ios.width(25); 12943 left(ios); 12944 { 12945 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12946 std::string ex(str, iter.base()); 12947 assert(ex == "0;000000*****************"); 12948 assert(ios.width() == 0); 12949 } 12950 ios.width(25); 12951 right(ios); 12952 { 12953 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12954 std::string ex(str, iter.base()); 12955 assert(ex == "*****************0;000000"); 12956 assert(ios.width() == 0); 12957 } 12958 ios.width(25); 12959 internal(ios); 12960 { 12961 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12962 std::string ex(str, iter.base()); 12963 assert(ex == "*****************0;000000"); 12964 assert(ios.width() == 0); 12965 } 12966 } 12967 } 12968 } 12969 showpos(ios); 12970 { 12971 noshowpoint(ios); 12972 { 12973 ios.imbue(lc); 12974 { 12975 ios.width(0); 12976 { 12977 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12978 std::string ex(str, iter.base()); 12979 assert(ex == "+0.000000"); 12980 assert(ios.width() == 0); 12981 } 12982 ios.width(25); 12983 left(ios); 12984 { 12985 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12986 std::string ex(str, iter.base()); 12987 assert(ex == "+0.000000****************"); 12988 assert(ios.width() == 0); 12989 } 12990 ios.width(25); 12991 right(ios); 12992 { 12993 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12994 std::string ex(str, iter.base()); 12995 assert(ex == "****************+0.000000"); 12996 assert(ios.width() == 0); 12997 } 12998 ios.width(25); 12999 internal(ios); 13000 { 13001 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13002 std::string ex(str, iter.base()); 13003 assert(ex == "+****************0.000000"); 13004 assert(ios.width() == 0); 13005 } 13006 } 13007 ios.imbue(lg); 13008 { 13009 ios.width(0); 13010 { 13011 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13012 std::string ex(str, iter.base()); 13013 assert(ex == "+0;000000"); 13014 assert(ios.width() == 0); 13015 } 13016 ios.width(25); 13017 left(ios); 13018 { 13019 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13020 std::string ex(str, iter.base()); 13021 assert(ex == "+0;000000****************"); 13022 assert(ios.width() == 0); 13023 } 13024 ios.width(25); 13025 right(ios); 13026 { 13027 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13028 std::string ex(str, iter.base()); 13029 assert(ex == "****************+0;000000"); 13030 assert(ios.width() == 0); 13031 } 13032 ios.width(25); 13033 internal(ios); 13034 { 13035 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13036 std::string ex(str, iter.base()); 13037 assert(ex == "+****************0;000000"); 13038 assert(ios.width() == 0); 13039 } 13040 } 13041 } 13042 showpoint(ios); 13043 { 13044 ios.imbue(lc); 13045 { 13046 ios.width(0); 13047 { 13048 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13049 std::string ex(str, iter.base()); 13050 assert(ex == "+0.000000"); 13051 assert(ios.width() == 0); 13052 } 13053 ios.width(25); 13054 left(ios); 13055 { 13056 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13057 std::string ex(str, iter.base()); 13058 assert(ex == "+0.000000****************"); 13059 assert(ios.width() == 0); 13060 } 13061 ios.width(25); 13062 right(ios); 13063 { 13064 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13065 std::string ex(str, iter.base()); 13066 assert(ex == "****************+0.000000"); 13067 assert(ios.width() == 0); 13068 } 13069 ios.width(25); 13070 internal(ios); 13071 { 13072 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13073 std::string ex(str, iter.base()); 13074 assert(ex == "+****************0.000000"); 13075 assert(ios.width() == 0); 13076 } 13077 } 13078 ios.imbue(lg); 13079 { 13080 ios.width(0); 13081 { 13082 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13083 std::string ex(str, iter.base()); 13084 assert(ex == "+0;000000"); 13085 assert(ios.width() == 0); 13086 } 13087 ios.width(25); 13088 left(ios); 13089 { 13090 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13091 std::string ex(str, iter.base()); 13092 assert(ex == "+0;000000****************"); 13093 assert(ios.width() == 0); 13094 } 13095 ios.width(25); 13096 right(ios); 13097 { 13098 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13099 std::string ex(str, iter.base()); 13100 assert(ex == "****************+0;000000"); 13101 assert(ios.width() == 0); 13102 } 13103 ios.width(25); 13104 internal(ios); 13105 { 13106 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13107 std::string ex(str, iter.base()); 13108 assert(ex == "+****************0;000000"); 13109 assert(ios.width() == 0); 13110 } 13111 } 13112 } 13113 } 13114 } 13115 } 13116 ios.precision(16); 13117 { 13118 nouppercase(ios); 13119 { 13120 noshowpos(ios); 13121 { 13122 noshowpoint(ios); 13123 { 13124 ios.imbue(lc); 13125 { 13126 ios.width(0); 13127 { 13128 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13129 std::string ex(str, iter.base()); 13130 assert(ex == "0.0000000000000000"); 13131 assert(ios.width() == 0); 13132 } 13133 ios.width(25); 13134 left(ios); 13135 { 13136 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13137 std::string ex(str, iter.base()); 13138 assert(ex == "0.0000000000000000*******"); 13139 assert(ios.width() == 0); 13140 } 13141 ios.width(25); 13142 right(ios); 13143 { 13144 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13145 std::string ex(str, iter.base()); 13146 assert(ex == "*******0.0000000000000000"); 13147 assert(ios.width() == 0); 13148 } 13149 ios.width(25); 13150 internal(ios); 13151 { 13152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13153 std::string ex(str, iter.base()); 13154 assert(ex == "*******0.0000000000000000"); 13155 assert(ios.width() == 0); 13156 } 13157 } 13158 ios.imbue(lg); 13159 { 13160 ios.width(0); 13161 { 13162 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13163 std::string ex(str, iter.base()); 13164 assert(ex == "0;0000000000000000"); 13165 assert(ios.width() == 0); 13166 } 13167 ios.width(25); 13168 left(ios); 13169 { 13170 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13171 std::string ex(str, iter.base()); 13172 assert(ex == "0;0000000000000000*******"); 13173 assert(ios.width() == 0); 13174 } 13175 ios.width(25); 13176 right(ios); 13177 { 13178 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13179 std::string ex(str, iter.base()); 13180 assert(ex == "*******0;0000000000000000"); 13181 assert(ios.width() == 0); 13182 } 13183 ios.width(25); 13184 internal(ios); 13185 { 13186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13187 std::string ex(str, iter.base()); 13188 assert(ex == "*******0;0000000000000000"); 13189 assert(ios.width() == 0); 13190 } 13191 } 13192 } 13193 showpoint(ios); 13194 { 13195 ios.imbue(lc); 13196 { 13197 ios.width(0); 13198 { 13199 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13200 std::string ex(str, iter.base()); 13201 assert(ex == "0.0000000000000000"); 13202 assert(ios.width() == 0); 13203 } 13204 ios.width(25); 13205 left(ios); 13206 { 13207 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13208 std::string ex(str, iter.base()); 13209 assert(ex == "0.0000000000000000*******"); 13210 assert(ios.width() == 0); 13211 } 13212 ios.width(25); 13213 right(ios); 13214 { 13215 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13216 std::string ex(str, iter.base()); 13217 assert(ex == "*******0.0000000000000000"); 13218 assert(ios.width() == 0); 13219 } 13220 ios.width(25); 13221 internal(ios); 13222 { 13223 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13224 std::string ex(str, iter.base()); 13225 assert(ex == "*******0.0000000000000000"); 13226 assert(ios.width() == 0); 13227 } 13228 } 13229 ios.imbue(lg); 13230 { 13231 ios.width(0); 13232 { 13233 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13234 std::string ex(str, iter.base()); 13235 assert(ex == "0;0000000000000000"); 13236 assert(ios.width() == 0); 13237 } 13238 ios.width(25); 13239 left(ios); 13240 { 13241 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13242 std::string ex(str, iter.base()); 13243 assert(ex == "0;0000000000000000*******"); 13244 assert(ios.width() == 0); 13245 } 13246 ios.width(25); 13247 right(ios); 13248 { 13249 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13250 std::string ex(str, iter.base()); 13251 assert(ex == "*******0;0000000000000000"); 13252 assert(ios.width() == 0); 13253 } 13254 ios.width(25); 13255 internal(ios); 13256 { 13257 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13258 std::string ex(str, iter.base()); 13259 assert(ex == "*******0;0000000000000000"); 13260 assert(ios.width() == 0); 13261 } 13262 } 13263 } 13264 } 13265 showpos(ios); 13266 { 13267 noshowpoint(ios); 13268 { 13269 ios.imbue(lc); 13270 { 13271 ios.width(0); 13272 { 13273 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13274 std::string ex(str, iter.base()); 13275 assert(ex == "+0.0000000000000000"); 13276 assert(ios.width() == 0); 13277 } 13278 ios.width(25); 13279 left(ios); 13280 { 13281 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13282 std::string ex(str, iter.base()); 13283 assert(ex == "+0.0000000000000000******"); 13284 assert(ios.width() == 0); 13285 } 13286 ios.width(25); 13287 right(ios); 13288 { 13289 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13290 std::string ex(str, iter.base()); 13291 assert(ex == "******+0.0000000000000000"); 13292 assert(ios.width() == 0); 13293 } 13294 ios.width(25); 13295 internal(ios); 13296 { 13297 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13298 std::string ex(str, iter.base()); 13299 assert(ex == "+******0.0000000000000000"); 13300 assert(ios.width() == 0); 13301 } 13302 } 13303 ios.imbue(lg); 13304 { 13305 ios.width(0); 13306 { 13307 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13308 std::string ex(str, iter.base()); 13309 assert(ex == "+0;0000000000000000"); 13310 assert(ios.width() == 0); 13311 } 13312 ios.width(25); 13313 left(ios); 13314 { 13315 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13316 std::string ex(str, iter.base()); 13317 assert(ex == "+0;0000000000000000******"); 13318 assert(ios.width() == 0); 13319 } 13320 ios.width(25); 13321 right(ios); 13322 { 13323 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13324 std::string ex(str, iter.base()); 13325 assert(ex == "******+0;0000000000000000"); 13326 assert(ios.width() == 0); 13327 } 13328 ios.width(25); 13329 internal(ios); 13330 { 13331 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13332 std::string ex(str, iter.base()); 13333 assert(ex == "+******0;0000000000000000"); 13334 assert(ios.width() == 0); 13335 } 13336 } 13337 } 13338 showpoint(ios); 13339 { 13340 ios.imbue(lc); 13341 { 13342 ios.width(0); 13343 { 13344 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13345 std::string ex(str, iter.base()); 13346 assert(ex == "+0.0000000000000000"); 13347 assert(ios.width() == 0); 13348 } 13349 ios.width(25); 13350 left(ios); 13351 { 13352 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13353 std::string ex(str, iter.base()); 13354 assert(ex == "+0.0000000000000000******"); 13355 assert(ios.width() == 0); 13356 } 13357 ios.width(25); 13358 right(ios); 13359 { 13360 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13361 std::string ex(str, iter.base()); 13362 assert(ex == "******+0.0000000000000000"); 13363 assert(ios.width() == 0); 13364 } 13365 ios.width(25); 13366 internal(ios); 13367 { 13368 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13369 std::string ex(str, iter.base()); 13370 assert(ex == "+******0.0000000000000000"); 13371 assert(ios.width() == 0); 13372 } 13373 } 13374 ios.imbue(lg); 13375 { 13376 ios.width(0); 13377 { 13378 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13379 std::string ex(str, iter.base()); 13380 assert(ex == "+0;0000000000000000"); 13381 assert(ios.width() == 0); 13382 } 13383 ios.width(25); 13384 left(ios); 13385 { 13386 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13387 std::string ex(str, iter.base()); 13388 assert(ex == "+0;0000000000000000******"); 13389 assert(ios.width() == 0); 13390 } 13391 ios.width(25); 13392 right(ios); 13393 { 13394 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13395 std::string ex(str, iter.base()); 13396 assert(ex == "******+0;0000000000000000"); 13397 assert(ios.width() == 0); 13398 } 13399 ios.width(25); 13400 internal(ios); 13401 { 13402 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13403 std::string ex(str, iter.base()); 13404 assert(ex == "+******0;0000000000000000"); 13405 assert(ios.width() == 0); 13406 } 13407 } 13408 } 13409 } 13410 } 13411 uppercase(ios); 13412 { 13413 noshowpos(ios); 13414 { 13415 noshowpoint(ios); 13416 { 13417 ios.imbue(lc); 13418 { 13419 ios.width(0); 13420 { 13421 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13422 std::string ex(str, iter.base()); 13423 assert(ex == "0.0000000000000000"); 13424 assert(ios.width() == 0); 13425 } 13426 ios.width(25); 13427 left(ios); 13428 { 13429 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13430 std::string ex(str, iter.base()); 13431 assert(ex == "0.0000000000000000*******"); 13432 assert(ios.width() == 0); 13433 } 13434 ios.width(25); 13435 right(ios); 13436 { 13437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13438 std::string ex(str, iter.base()); 13439 assert(ex == "*******0.0000000000000000"); 13440 assert(ios.width() == 0); 13441 } 13442 ios.width(25); 13443 internal(ios); 13444 { 13445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13446 std::string ex(str, iter.base()); 13447 assert(ex == "*******0.0000000000000000"); 13448 assert(ios.width() == 0); 13449 } 13450 } 13451 ios.imbue(lg); 13452 { 13453 ios.width(0); 13454 { 13455 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13456 std::string ex(str, iter.base()); 13457 assert(ex == "0;0000000000000000"); 13458 assert(ios.width() == 0); 13459 } 13460 ios.width(25); 13461 left(ios); 13462 { 13463 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13464 std::string ex(str, iter.base()); 13465 assert(ex == "0;0000000000000000*******"); 13466 assert(ios.width() == 0); 13467 } 13468 ios.width(25); 13469 right(ios); 13470 { 13471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13472 std::string ex(str, iter.base()); 13473 assert(ex == "*******0;0000000000000000"); 13474 assert(ios.width() == 0); 13475 } 13476 ios.width(25); 13477 internal(ios); 13478 { 13479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13480 std::string ex(str, iter.base()); 13481 assert(ex == "*******0;0000000000000000"); 13482 assert(ios.width() == 0); 13483 } 13484 } 13485 } 13486 showpoint(ios); 13487 { 13488 ios.imbue(lc); 13489 { 13490 ios.width(0); 13491 { 13492 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13493 std::string ex(str, iter.base()); 13494 assert(ex == "0.0000000000000000"); 13495 assert(ios.width() == 0); 13496 } 13497 ios.width(25); 13498 left(ios); 13499 { 13500 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13501 std::string ex(str, iter.base()); 13502 assert(ex == "0.0000000000000000*******"); 13503 assert(ios.width() == 0); 13504 } 13505 ios.width(25); 13506 right(ios); 13507 { 13508 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13509 std::string ex(str, iter.base()); 13510 assert(ex == "*******0.0000000000000000"); 13511 assert(ios.width() == 0); 13512 } 13513 ios.width(25); 13514 internal(ios); 13515 { 13516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13517 std::string ex(str, iter.base()); 13518 assert(ex == "*******0.0000000000000000"); 13519 assert(ios.width() == 0); 13520 } 13521 } 13522 ios.imbue(lg); 13523 { 13524 ios.width(0); 13525 { 13526 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13527 std::string ex(str, iter.base()); 13528 assert(ex == "0;0000000000000000"); 13529 assert(ios.width() == 0); 13530 } 13531 ios.width(25); 13532 left(ios); 13533 { 13534 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13535 std::string ex(str, iter.base()); 13536 assert(ex == "0;0000000000000000*******"); 13537 assert(ios.width() == 0); 13538 } 13539 ios.width(25); 13540 right(ios); 13541 { 13542 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13543 std::string ex(str, iter.base()); 13544 assert(ex == "*******0;0000000000000000"); 13545 assert(ios.width() == 0); 13546 } 13547 ios.width(25); 13548 internal(ios); 13549 { 13550 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13551 std::string ex(str, iter.base()); 13552 assert(ex == "*******0;0000000000000000"); 13553 assert(ios.width() == 0); 13554 } 13555 } 13556 } 13557 } 13558 showpos(ios); 13559 { 13560 noshowpoint(ios); 13561 { 13562 ios.imbue(lc); 13563 { 13564 ios.width(0); 13565 { 13566 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13567 std::string ex(str, iter.base()); 13568 assert(ex == "+0.0000000000000000"); 13569 assert(ios.width() == 0); 13570 } 13571 ios.width(25); 13572 left(ios); 13573 { 13574 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13575 std::string ex(str, iter.base()); 13576 assert(ex == "+0.0000000000000000******"); 13577 assert(ios.width() == 0); 13578 } 13579 ios.width(25); 13580 right(ios); 13581 { 13582 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13583 std::string ex(str, iter.base()); 13584 assert(ex == "******+0.0000000000000000"); 13585 assert(ios.width() == 0); 13586 } 13587 ios.width(25); 13588 internal(ios); 13589 { 13590 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13591 std::string ex(str, iter.base()); 13592 assert(ex == "+******0.0000000000000000"); 13593 assert(ios.width() == 0); 13594 } 13595 } 13596 ios.imbue(lg); 13597 { 13598 ios.width(0); 13599 { 13600 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13601 std::string ex(str, iter.base()); 13602 assert(ex == "+0;0000000000000000"); 13603 assert(ios.width() == 0); 13604 } 13605 ios.width(25); 13606 left(ios); 13607 { 13608 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13609 std::string ex(str, iter.base()); 13610 assert(ex == "+0;0000000000000000******"); 13611 assert(ios.width() == 0); 13612 } 13613 ios.width(25); 13614 right(ios); 13615 { 13616 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13617 std::string ex(str, iter.base()); 13618 assert(ex == "******+0;0000000000000000"); 13619 assert(ios.width() == 0); 13620 } 13621 ios.width(25); 13622 internal(ios); 13623 { 13624 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13625 std::string ex(str, iter.base()); 13626 assert(ex == "+******0;0000000000000000"); 13627 assert(ios.width() == 0); 13628 } 13629 } 13630 } 13631 showpoint(ios); 13632 { 13633 ios.imbue(lc); 13634 { 13635 ios.width(0); 13636 { 13637 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13638 std::string ex(str, iter.base()); 13639 assert(ex == "+0.0000000000000000"); 13640 assert(ios.width() == 0); 13641 } 13642 ios.width(25); 13643 left(ios); 13644 { 13645 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13646 std::string ex(str, iter.base()); 13647 assert(ex == "+0.0000000000000000******"); 13648 assert(ios.width() == 0); 13649 } 13650 ios.width(25); 13651 right(ios); 13652 { 13653 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13654 std::string ex(str, iter.base()); 13655 assert(ex == "******+0.0000000000000000"); 13656 assert(ios.width() == 0); 13657 } 13658 ios.width(25); 13659 internal(ios); 13660 { 13661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13662 std::string ex(str, iter.base()); 13663 assert(ex == "+******0.0000000000000000"); 13664 assert(ios.width() == 0); 13665 } 13666 } 13667 ios.imbue(lg); 13668 { 13669 ios.width(0); 13670 { 13671 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13672 std::string ex(str, iter.base()); 13673 assert(ex == "+0;0000000000000000"); 13674 assert(ios.width() == 0); 13675 } 13676 ios.width(25); 13677 left(ios); 13678 { 13679 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13680 std::string ex(str, iter.base()); 13681 assert(ex == "+0;0000000000000000******"); 13682 assert(ios.width() == 0); 13683 } 13684 ios.width(25); 13685 right(ios); 13686 { 13687 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13688 std::string ex(str, iter.base()); 13689 assert(ex == "******+0;0000000000000000"); 13690 assert(ios.width() == 0); 13691 } 13692 ios.width(25); 13693 internal(ios); 13694 { 13695 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13696 std::string ex(str, iter.base()); 13697 assert(ex == "+******0;0000000000000000"); 13698 assert(ios.width() == 0); 13699 } 13700 } 13701 } 13702 } 13703 } 13704 } 13705 ios.precision(60); 13706 { 13707 nouppercase(ios); 13708 { 13709 noshowpos(ios); 13710 { 13711 noshowpoint(ios); 13712 { 13713 ios.imbue(lc); 13714 { 13715 ios.width(0); 13716 { 13717 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13718 std::string ex(str, iter.base()); 13719 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13720 assert(ios.width() == 0); 13721 } 13722 ios.width(25); 13723 left(ios); 13724 { 13725 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13726 std::string ex(str, iter.base()); 13727 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13728 assert(ios.width() == 0); 13729 } 13730 ios.width(25); 13731 right(ios); 13732 { 13733 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13734 std::string ex(str, iter.base()); 13735 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13736 assert(ios.width() == 0); 13737 } 13738 ios.width(25); 13739 internal(ios); 13740 { 13741 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13742 std::string ex(str, iter.base()); 13743 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13744 assert(ios.width() == 0); 13745 } 13746 } 13747 ios.imbue(lg); 13748 { 13749 ios.width(0); 13750 { 13751 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13752 std::string ex(str, iter.base()); 13753 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13754 assert(ios.width() == 0); 13755 } 13756 ios.width(25); 13757 left(ios); 13758 { 13759 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13760 std::string ex(str, iter.base()); 13761 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13762 assert(ios.width() == 0); 13763 } 13764 ios.width(25); 13765 right(ios); 13766 { 13767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13768 std::string ex(str, iter.base()); 13769 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13770 assert(ios.width() == 0); 13771 } 13772 ios.width(25); 13773 internal(ios); 13774 { 13775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13776 std::string ex(str, iter.base()); 13777 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13778 assert(ios.width() == 0); 13779 } 13780 } 13781 } 13782 showpoint(ios); 13783 { 13784 ios.imbue(lc); 13785 { 13786 ios.width(0); 13787 { 13788 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13789 std::string ex(str, iter.base()); 13790 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13791 assert(ios.width() == 0); 13792 } 13793 ios.width(25); 13794 left(ios); 13795 { 13796 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13797 std::string ex(str, iter.base()); 13798 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13799 assert(ios.width() == 0); 13800 } 13801 ios.width(25); 13802 right(ios); 13803 { 13804 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13805 std::string ex(str, iter.base()); 13806 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13807 assert(ios.width() == 0); 13808 } 13809 ios.width(25); 13810 internal(ios); 13811 { 13812 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13813 std::string ex(str, iter.base()); 13814 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 13815 assert(ios.width() == 0); 13816 } 13817 } 13818 ios.imbue(lg); 13819 { 13820 ios.width(0); 13821 { 13822 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13823 std::string ex(str, iter.base()); 13824 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13825 assert(ios.width() == 0); 13826 } 13827 ios.width(25); 13828 left(ios); 13829 { 13830 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13831 std::string ex(str, iter.base()); 13832 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13833 assert(ios.width() == 0); 13834 } 13835 ios.width(25); 13836 right(ios); 13837 { 13838 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13839 std::string ex(str, iter.base()); 13840 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13841 assert(ios.width() == 0); 13842 } 13843 ios.width(25); 13844 internal(ios); 13845 { 13846 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13847 std::string ex(str, iter.base()); 13848 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 13849 assert(ios.width() == 0); 13850 } 13851 } 13852 } 13853 } 13854 showpos(ios); 13855 { 13856 noshowpoint(ios); 13857 { 13858 ios.imbue(lc); 13859 { 13860 ios.width(0); 13861 { 13862 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13863 std::string ex(str, iter.base()); 13864 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13865 assert(ios.width() == 0); 13866 } 13867 ios.width(25); 13868 left(ios); 13869 { 13870 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13871 std::string ex(str, iter.base()); 13872 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13873 assert(ios.width() == 0); 13874 } 13875 ios.width(25); 13876 right(ios); 13877 { 13878 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13879 std::string ex(str, iter.base()); 13880 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13881 assert(ios.width() == 0); 13882 } 13883 ios.width(25); 13884 internal(ios); 13885 { 13886 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13887 std::string ex(str, iter.base()); 13888 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13889 assert(ios.width() == 0); 13890 } 13891 } 13892 ios.imbue(lg); 13893 { 13894 ios.width(0); 13895 { 13896 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13897 std::string ex(str, iter.base()); 13898 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13899 assert(ios.width() == 0); 13900 } 13901 ios.width(25); 13902 left(ios); 13903 { 13904 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13905 std::string ex(str, iter.base()); 13906 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13907 assert(ios.width() == 0); 13908 } 13909 ios.width(25); 13910 right(ios); 13911 { 13912 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13913 std::string ex(str, iter.base()); 13914 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13915 assert(ios.width() == 0); 13916 } 13917 ios.width(25); 13918 internal(ios); 13919 { 13920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13921 std::string ex(str, iter.base()); 13922 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13923 assert(ios.width() == 0); 13924 } 13925 } 13926 } 13927 showpoint(ios); 13928 { 13929 ios.imbue(lc); 13930 { 13931 ios.width(0); 13932 { 13933 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13934 std::string ex(str, iter.base()); 13935 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13936 assert(ios.width() == 0); 13937 } 13938 ios.width(25); 13939 left(ios); 13940 { 13941 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13942 std::string ex(str, iter.base()); 13943 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13944 assert(ios.width() == 0); 13945 } 13946 ios.width(25); 13947 right(ios); 13948 { 13949 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13950 std::string ex(str, iter.base()); 13951 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13952 assert(ios.width() == 0); 13953 } 13954 ios.width(25); 13955 internal(ios); 13956 { 13957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13958 std::string ex(str, iter.base()); 13959 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 13960 assert(ios.width() == 0); 13961 } 13962 } 13963 ios.imbue(lg); 13964 { 13965 ios.width(0); 13966 { 13967 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13968 std::string ex(str, iter.base()); 13969 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13970 assert(ios.width() == 0); 13971 } 13972 ios.width(25); 13973 left(ios); 13974 { 13975 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13976 std::string ex(str, iter.base()); 13977 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13978 assert(ios.width() == 0); 13979 } 13980 ios.width(25); 13981 right(ios); 13982 { 13983 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13984 std::string ex(str, iter.base()); 13985 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13986 assert(ios.width() == 0); 13987 } 13988 ios.width(25); 13989 internal(ios); 13990 { 13991 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13992 std::string ex(str, iter.base()); 13993 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 13994 assert(ios.width() == 0); 13995 } 13996 } 13997 } 13998 } 13999 } 14000 uppercase(ios); 14001 { 14002 noshowpos(ios); 14003 { 14004 noshowpoint(ios); 14005 { 14006 ios.imbue(lc); 14007 { 14008 ios.width(0); 14009 { 14010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14011 std::string ex(str, iter.base()); 14012 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14013 assert(ios.width() == 0); 14014 } 14015 ios.width(25); 14016 left(ios); 14017 { 14018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14019 std::string ex(str, iter.base()); 14020 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14021 assert(ios.width() == 0); 14022 } 14023 ios.width(25); 14024 right(ios); 14025 { 14026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14027 std::string ex(str, iter.base()); 14028 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14029 assert(ios.width() == 0); 14030 } 14031 ios.width(25); 14032 internal(ios); 14033 { 14034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14035 std::string ex(str, iter.base()); 14036 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14037 assert(ios.width() == 0); 14038 } 14039 } 14040 ios.imbue(lg); 14041 { 14042 ios.width(0); 14043 { 14044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14045 std::string ex(str, iter.base()); 14046 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14047 assert(ios.width() == 0); 14048 } 14049 ios.width(25); 14050 left(ios); 14051 { 14052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14053 std::string ex(str, iter.base()); 14054 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14055 assert(ios.width() == 0); 14056 } 14057 ios.width(25); 14058 right(ios); 14059 { 14060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14061 std::string ex(str, iter.base()); 14062 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14063 assert(ios.width() == 0); 14064 } 14065 ios.width(25); 14066 internal(ios); 14067 { 14068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14069 std::string ex(str, iter.base()); 14070 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14071 assert(ios.width() == 0); 14072 } 14073 } 14074 } 14075 showpoint(ios); 14076 { 14077 ios.imbue(lc); 14078 { 14079 ios.width(0); 14080 { 14081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14082 std::string ex(str, iter.base()); 14083 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14084 assert(ios.width() == 0); 14085 } 14086 ios.width(25); 14087 left(ios); 14088 { 14089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14090 std::string ex(str, iter.base()); 14091 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14092 assert(ios.width() == 0); 14093 } 14094 ios.width(25); 14095 right(ios); 14096 { 14097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14098 std::string ex(str, iter.base()); 14099 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14100 assert(ios.width() == 0); 14101 } 14102 ios.width(25); 14103 internal(ios); 14104 { 14105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14106 std::string ex(str, iter.base()); 14107 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 14108 assert(ios.width() == 0); 14109 } 14110 } 14111 ios.imbue(lg); 14112 { 14113 ios.width(0); 14114 { 14115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14116 std::string ex(str, iter.base()); 14117 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14118 assert(ios.width() == 0); 14119 } 14120 ios.width(25); 14121 left(ios); 14122 { 14123 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14124 std::string ex(str, iter.base()); 14125 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14126 assert(ios.width() == 0); 14127 } 14128 ios.width(25); 14129 right(ios); 14130 { 14131 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14132 std::string ex(str, iter.base()); 14133 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14134 assert(ios.width() == 0); 14135 } 14136 ios.width(25); 14137 internal(ios); 14138 { 14139 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14140 std::string ex(str, iter.base()); 14141 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 14142 assert(ios.width() == 0); 14143 } 14144 } 14145 } 14146 } 14147 showpos(ios); 14148 { 14149 noshowpoint(ios); 14150 { 14151 ios.imbue(lc); 14152 { 14153 ios.width(0); 14154 { 14155 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14156 std::string ex(str, iter.base()); 14157 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14158 assert(ios.width() == 0); 14159 } 14160 ios.width(25); 14161 left(ios); 14162 { 14163 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14164 std::string ex(str, iter.base()); 14165 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14166 assert(ios.width() == 0); 14167 } 14168 ios.width(25); 14169 right(ios); 14170 { 14171 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14172 std::string ex(str, iter.base()); 14173 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14174 assert(ios.width() == 0); 14175 } 14176 ios.width(25); 14177 internal(ios); 14178 { 14179 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14180 std::string ex(str, iter.base()); 14181 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14182 assert(ios.width() == 0); 14183 } 14184 } 14185 ios.imbue(lg); 14186 { 14187 ios.width(0); 14188 { 14189 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14190 std::string ex(str, iter.base()); 14191 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14192 assert(ios.width() == 0); 14193 } 14194 ios.width(25); 14195 left(ios); 14196 { 14197 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14198 std::string ex(str, iter.base()); 14199 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14200 assert(ios.width() == 0); 14201 } 14202 ios.width(25); 14203 right(ios); 14204 { 14205 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14206 std::string ex(str, iter.base()); 14207 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14208 assert(ios.width() == 0); 14209 } 14210 ios.width(25); 14211 internal(ios); 14212 { 14213 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14214 std::string ex(str, iter.base()); 14215 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14216 assert(ios.width() == 0); 14217 } 14218 } 14219 } 14220 showpoint(ios); 14221 { 14222 ios.imbue(lc); 14223 { 14224 ios.width(0); 14225 { 14226 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14227 std::string ex(str, iter.base()); 14228 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14229 assert(ios.width() == 0); 14230 } 14231 ios.width(25); 14232 left(ios); 14233 { 14234 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14235 std::string ex(str, iter.base()); 14236 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14237 assert(ios.width() == 0); 14238 } 14239 ios.width(25); 14240 right(ios); 14241 { 14242 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14243 std::string ex(str, iter.base()); 14244 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14245 assert(ios.width() == 0); 14246 } 14247 ios.width(25); 14248 internal(ios); 14249 { 14250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14251 std::string ex(str, iter.base()); 14252 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 14253 assert(ios.width() == 0); 14254 } 14255 } 14256 ios.imbue(lg); 14257 { 14258 ios.width(0); 14259 { 14260 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14261 std::string ex(str, iter.base()); 14262 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14263 assert(ios.width() == 0); 14264 } 14265 ios.width(25); 14266 left(ios); 14267 { 14268 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14269 std::string ex(str, iter.base()); 14270 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14271 assert(ios.width() == 0); 14272 } 14273 ios.width(25); 14274 right(ios); 14275 { 14276 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14277 std::string ex(str, iter.base()); 14278 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14279 assert(ios.width() == 0); 14280 } 14281 ios.width(25); 14282 internal(ios); 14283 { 14284 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14285 std::string ex(str, iter.base()); 14286 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 14287 assert(ios.width() == 0); 14288 } 14289 } 14290 } 14291 } 14292 } 14293 } 14294 } 14295 } 14296 } 14297 14298 void test7() 14299 { 14300 char str[200]; 14301 output_iterator<char*> iter; 14302 std::locale lc = std::locale::classic(); 14303 std::locale lg(lc, new my_numpunct); 14304 const my_facet f(1); 14305 { 14306 long double v = -0.; 14307 std::ios ios(0); 14308 fixed(ios); 14309 // %f 14310 { 14311 ios.precision(0); 14312 { 14313 nouppercase(ios); 14314 { 14315 noshowpos(ios); 14316 { 14317 noshowpoint(ios); 14318 { 14319 ios.imbue(lc); 14320 { 14321 ios.width(0); 14322 { 14323 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14324 std::string ex(str, iter.base()); 14325 assert(ex == "-0"); 14326 assert(ios.width() == 0); 14327 } 14328 ios.width(25); 14329 left(ios); 14330 { 14331 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14332 std::string ex(str, iter.base()); 14333 assert(ex == "-0***********************"); 14334 assert(ios.width() == 0); 14335 } 14336 ios.width(25); 14337 right(ios); 14338 { 14339 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14340 std::string ex(str, iter.base()); 14341 assert(ex == "***********************-0"); 14342 assert(ios.width() == 0); 14343 } 14344 ios.width(25); 14345 internal(ios); 14346 { 14347 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14348 std::string ex(str, iter.base()); 14349 assert(ex == "-***********************0"); 14350 assert(ios.width() == 0); 14351 } 14352 } 14353 ios.imbue(lg); 14354 { 14355 ios.width(0); 14356 { 14357 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14358 std::string ex(str, iter.base()); 14359 assert(ex == "-0"); 14360 assert(ios.width() == 0); 14361 } 14362 ios.width(25); 14363 left(ios); 14364 { 14365 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14366 std::string ex(str, iter.base()); 14367 assert(ex == "-0***********************"); 14368 assert(ios.width() == 0); 14369 } 14370 ios.width(25); 14371 right(ios); 14372 { 14373 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14374 std::string ex(str, iter.base()); 14375 assert(ex == "***********************-0"); 14376 assert(ios.width() == 0); 14377 } 14378 ios.width(25); 14379 internal(ios); 14380 { 14381 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14382 std::string ex(str, iter.base()); 14383 assert(ex == "-***********************0"); 14384 assert(ios.width() == 0); 14385 } 14386 } 14387 } 14388 showpoint(ios); 14389 { 14390 ios.imbue(lc); 14391 { 14392 ios.width(0); 14393 { 14394 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14395 std::string ex(str, iter.base()); 14396 assert(ex == "-0."); 14397 assert(ios.width() == 0); 14398 } 14399 ios.width(25); 14400 left(ios); 14401 { 14402 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14403 std::string ex(str, iter.base()); 14404 assert(ex == "-0.**********************"); 14405 assert(ios.width() == 0); 14406 } 14407 ios.width(25); 14408 right(ios); 14409 { 14410 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14411 std::string ex(str, iter.base()); 14412 assert(ex == "**********************-0."); 14413 assert(ios.width() == 0); 14414 } 14415 ios.width(25); 14416 internal(ios); 14417 { 14418 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14419 std::string ex(str, iter.base()); 14420 assert(ex == "-**********************0."); 14421 assert(ios.width() == 0); 14422 } 14423 } 14424 ios.imbue(lg); 14425 { 14426 ios.width(0); 14427 { 14428 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14429 std::string ex(str, iter.base()); 14430 assert(ex == "-0;"); 14431 assert(ios.width() == 0); 14432 } 14433 ios.width(25); 14434 left(ios); 14435 { 14436 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14437 std::string ex(str, iter.base()); 14438 assert(ex == "-0;**********************"); 14439 assert(ios.width() == 0); 14440 } 14441 ios.width(25); 14442 right(ios); 14443 { 14444 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14445 std::string ex(str, iter.base()); 14446 assert(ex == "**********************-0;"); 14447 assert(ios.width() == 0); 14448 } 14449 ios.width(25); 14450 internal(ios); 14451 { 14452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14453 std::string ex(str, iter.base()); 14454 assert(ex == "-**********************0;"); 14455 assert(ios.width() == 0); 14456 } 14457 } 14458 } 14459 } 14460 showpos(ios); 14461 { 14462 noshowpoint(ios); 14463 { 14464 ios.imbue(lc); 14465 { 14466 ios.width(0); 14467 { 14468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14469 std::string ex(str, iter.base()); 14470 assert(ex == "-0"); 14471 assert(ios.width() == 0); 14472 } 14473 ios.width(25); 14474 left(ios); 14475 { 14476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14477 std::string ex(str, iter.base()); 14478 assert(ex == "-0***********************"); 14479 assert(ios.width() == 0); 14480 } 14481 ios.width(25); 14482 right(ios); 14483 { 14484 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14485 std::string ex(str, iter.base()); 14486 assert(ex == "***********************-0"); 14487 assert(ios.width() == 0); 14488 } 14489 ios.width(25); 14490 internal(ios); 14491 { 14492 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14493 std::string ex(str, iter.base()); 14494 assert(ex == "-***********************0"); 14495 assert(ios.width() == 0); 14496 } 14497 } 14498 ios.imbue(lg); 14499 { 14500 ios.width(0); 14501 { 14502 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14503 std::string ex(str, iter.base()); 14504 assert(ex == "-0"); 14505 assert(ios.width() == 0); 14506 } 14507 ios.width(25); 14508 left(ios); 14509 { 14510 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14511 std::string ex(str, iter.base()); 14512 assert(ex == "-0***********************"); 14513 assert(ios.width() == 0); 14514 } 14515 ios.width(25); 14516 right(ios); 14517 { 14518 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14519 std::string ex(str, iter.base()); 14520 assert(ex == "***********************-0"); 14521 assert(ios.width() == 0); 14522 } 14523 ios.width(25); 14524 internal(ios); 14525 { 14526 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14527 std::string ex(str, iter.base()); 14528 assert(ex == "-***********************0"); 14529 assert(ios.width() == 0); 14530 } 14531 } 14532 } 14533 showpoint(ios); 14534 { 14535 ios.imbue(lc); 14536 { 14537 ios.width(0); 14538 { 14539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14540 std::string ex(str, iter.base()); 14541 assert(ex == "-0."); 14542 assert(ios.width() == 0); 14543 } 14544 ios.width(25); 14545 left(ios); 14546 { 14547 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14548 std::string ex(str, iter.base()); 14549 assert(ex == "-0.**********************"); 14550 assert(ios.width() == 0); 14551 } 14552 ios.width(25); 14553 right(ios); 14554 { 14555 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14556 std::string ex(str, iter.base()); 14557 assert(ex == "**********************-0."); 14558 assert(ios.width() == 0); 14559 } 14560 ios.width(25); 14561 internal(ios); 14562 { 14563 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14564 std::string ex(str, iter.base()); 14565 assert(ex == "-**********************0."); 14566 assert(ios.width() == 0); 14567 } 14568 } 14569 ios.imbue(lg); 14570 { 14571 ios.width(0); 14572 { 14573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14574 std::string ex(str, iter.base()); 14575 assert(ex == "-0;"); 14576 assert(ios.width() == 0); 14577 } 14578 ios.width(25); 14579 left(ios); 14580 { 14581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14582 std::string ex(str, iter.base()); 14583 assert(ex == "-0;**********************"); 14584 assert(ios.width() == 0); 14585 } 14586 ios.width(25); 14587 right(ios); 14588 { 14589 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14590 std::string ex(str, iter.base()); 14591 assert(ex == "**********************-0;"); 14592 assert(ios.width() == 0); 14593 } 14594 ios.width(25); 14595 internal(ios); 14596 { 14597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14598 std::string ex(str, iter.base()); 14599 assert(ex == "-**********************0;"); 14600 assert(ios.width() == 0); 14601 } 14602 } 14603 } 14604 } 14605 } 14606 uppercase(ios); 14607 { 14608 noshowpos(ios); 14609 { 14610 noshowpoint(ios); 14611 { 14612 ios.imbue(lc); 14613 { 14614 ios.width(0); 14615 { 14616 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14617 std::string ex(str, iter.base()); 14618 assert(ex == "-0"); 14619 assert(ios.width() == 0); 14620 } 14621 ios.width(25); 14622 left(ios); 14623 { 14624 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14625 std::string ex(str, iter.base()); 14626 assert(ex == "-0***********************"); 14627 assert(ios.width() == 0); 14628 } 14629 ios.width(25); 14630 right(ios); 14631 { 14632 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14633 std::string ex(str, iter.base()); 14634 assert(ex == "***********************-0"); 14635 assert(ios.width() == 0); 14636 } 14637 ios.width(25); 14638 internal(ios); 14639 { 14640 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14641 std::string ex(str, iter.base()); 14642 assert(ex == "-***********************0"); 14643 assert(ios.width() == 0); 14644 } 14645 } 14646 ios.imbue(lg); 14647 { 14648 ios.width(0); 14649 { 14650 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14651 std::string ex(str, iter.base()); 14652 assert(ex == "-0"); 14653 assert(ios.width() == 0); 14654 } 14655 ios.width(25); 14656 left(ios); 14657 { 14658 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14659 std::string ex(str, iter.base()); 14660 assert(ex == "-0***********************"); 14661 assert(ios.width() == 0); 14662 } 14663 ios.width(25); 14664 right(ios); 14665 { 14666 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14667 std::string ex(str, iter.base()); 14668 assert(ex == "***********************-0"); 14669 assert(ios.width() == 0); 14670 } 14671 ios.width(25); 14672 internal(ios); 14673 { 14674 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14675 std::string ex(str, iter.base()); 14676 assert(ex == "-***********************0"); 14677 assert(ios.width() == 0); 14678 } 14679 } 14680 } 14681 showpoint(ios); 14682 { 14683 ios.imbue(lc); 14684 { 14685 ios.width(0); 14686 { 14687 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14688 std::string ex(str, iter.base()); 14689 assert(ex == "-0."); 14690 assert(ios.width() == 0); 14691 } 14692 ios.width(25); 14693 left(ios); 14694 { 14695 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14696 std::string ex(str, iter.base()); 14697 assert(ex == "-0.**********************"); 14698 assert(ios.width() == 0); 14699 } 14700 ios.width(25); 14701 right(ios); 14702 { 14703 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14704 std::string ex(str, iter.base()); 14705 assert(ex == "**********************-0."); 14706 assert(ios.width() == 0); 14707 } 14708 ios.width(25); 14709 internal(ios); 14710 { 14711 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14712 std::string ex(str, iter.base()); 14713 assert(ex == "-**********************0."); 14714 assert(ios.width() == 0); 14715 } 14716 } 14717 ios.imbue(lg); 14718 { 14719 ios.width(0); 14720 { 14721 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14722 std::string ex(str, iter.base()); 14723 assert(ex == "-0;"); 14724 assert(ios.width() == 0); 14725 } 14726 ios.width(25); 14727 left(ios); 14728 { 14729 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14730 std::string ex(str, iter.base()); 14731 assert(ex == "-0;**********************"); 14732 assert(ios.width() == 0); 14733 } 14734 ios.width(25); 14735 right(ios); 14736 { 14737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14738 std::string ex(str, iter.base()); 14739 assert(ex == "**********************-0;"); 14740 assert(ios.width() == 0); 14741 } 14742 ios.width(25); 14743 internal(ios); 14744 { 14745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14746 std::string ex(str, iter.base()); 14747 assert(ex == "-**********************0;"); 14748 assert(ios.width() == 0); 14749 } 14750 } 14751 } 14752 } 14753 showpos(ios); 14754 { 14755 noshowpoint(ios); 14756 { 14757 ios.imbue(lc); 14758 { 14759 ios.width(0); 14760 { 14761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14762 std::string ex(str, iter.base()); 14763 assert(ex == "-0"); 14764 assert(ios.width() == 0); 14765 } 14766 ios.width(25); 14767 left(ios); 14768 { 14769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14770 std::string ex(str, iter.base()); 14771 assert(ex == "-0***********************"); 14772 assert(ios.width() == 0); 14773 } 14774 ios.width(25); 14775 right(ios); 14776 { 14777 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14778 std::string ex(str, iter.base()); 14779 assert(ex == "***********************-0"); 14780 assert(ios.width() == 0); 14781 } 14782 ios.width(25); 14783 internal(ios); 14784 { 14785 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14786 std::string ex(str, iter.base()); 14787 assert(ex == "-***********************0"); 14788 assert(ios.width() == 0); 14789 } 14790 } 14791 ios.imbue(lg); 14792 { 14793 ios.width(0); 14794 { 14795 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14796 std::string ex(str, iter.base()); 14797 assert(ex == "-0"); 14798 assert(ios.width() == 0); 14799 } 14800 ios.width(25); 14801 left(ios); 14802 { 14803 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14804 std::string ex(str, iter.base()); 14805 assert(ex == "-0***********************"); 14806 assert(ios.width() == 0); 14807 } 14808 ios.width(25); 14809 right(ios); 14810 { 14811 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14812 std::string ex(str, iter.base()); 14813 assert(ex == "***********************-0"); 14814 assert(ios.width() == 0); 14815 } 14816 ios.width(25); 14817 internal(ios); 14818 { 14819 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14820 std::string ex(str, iter.base()); 14821 assert(ex == "-***********************0"); 14822 assert(ios.width() == 0); 14823 } 14824 } 14825 } 14826 showpoint(ios); 14827 { 14828 ios.imbue(lc); 14829 { 14830 ios.width(0); 14831 { 14832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14833 std::string ex(str, iter.base()); 14834 assert(ex == "-0."); 14835 assert(ios.width() == 0); 14836 } 14837 ios.width(25); 14838 left(ios); 14839 { 14840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14841 std::string ex(str, iter.base()); 14842 assert(ex == "-0.**********************"); 14843 assert(ios.width() == 0); 14844 } 14845 ios.width(25); 14846 right(ios); 14847 { 14848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14849 std::string ex(str, iter.base()); 14850 assert(ex == "**********************-0."); 14851 assert(ios.width() == 0); 14852 } 14853 ios.width(25); 14854 internal(ios); 14855 { 14856 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14857 std::string ex(str, iter.base()); 14858 assert(ex == "-**********************0."); 14859 assert(ios.width() == 0); 14860 } 14861 } 14862 ios.imbue(lg); 14863 { 14864 ios.width(0); 14865 { 14866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14867 std::string ex(str, iter.base()); 14868 assert(ex == "-0;"); 14869 assert(ios.width() == 0); 14870 } 14871 ios.width(25); 14872 left(ios); 14873 { 14874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14875 std::string ex(str, iter.base()); 14876 assert(ex == "-0;**********************"); 14877 assert(ios.width() == 0); 14878 } 14879 ios.width(25); 14880 right(ios); 14881 { 14882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14883 std::string ex(str, iter.base()); 14884 assert(ex == "**********************-0;"); 14885 assert(ios.width() == 0); 14886 } 14887 ios.width(25); 14888 internal(ios); 14889 { 14890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14891 std::string ex(str, iter.base()); 14892 assert(ex == "-**********************0;"); 14893 assert(ios.width() == 0); 14894 } 14895 } 14896 } 14897 } 14898 } 14899 } 14900 ios.precision(1); 14901 { 14902 nouppercase(ios); 14903 { 14904 noshowpos(ios); 14905 { 14906 noshowpoint(ios); 14907 { 14908 ios.imbue(lc); 14909 { 14910 ios.width(0); 14911 { 14912 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14913 std::string ex(str, iter.base()); 14914 assert(ex == "-0.0"); 14915 assert(ios.width() == 0); 14916 } 14917 ios.width(25); 14918 left(ios); 14919 { 14920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14921 std::string ex(str, iter.base()); 14922 assert(ex == "-0.0*********************"); 14923 assert(ios.width() == 0); 14924 } 14925 ios.width(25); 14926 right(ios); 14927 { 14928 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14929 std::string ex(str, iter.base()); 14930 assert(ex == "*********************-0.0"); 14931 assert(ios.width() == 0); 14932 } 14933 ios.width(25); 14934 internal(ios); 14935 { 14936 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14937 std::string ex(str, iter.base()); 14938 assert(ex == "-*********************0.0"); 14939 assert(ios.width() == 0); 14940 } 14941 } 14942 ios.imbue(lg); 14943 { 14944 ios.width(0); 14945 { 14946 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14947 std::string ex(str, iter.base()); 14948 assert(ex == "-0;0"); 14949 assert(ios.width() == 0); 14950 } 14951 ios.width(25); 14952 left(ios); 14953 { 14954 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14955 std::string ex(str, iter.base()); 14956 assert(ex == "-0;0*********************"); 14957 assert(ios.width() == 0); 14958 } 14959 ios.width(25); 14960 right(ios); 14961 { 14962 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14963 std::string ex(str, iter.base()); 14964 assert(ex == "*********************-0;0"); 14965 assert(ios.width() == 0); 14966 } 14967 ios.width(25); 14968 internal(ios); 14969 { 14970 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14971 std::string ex(str, iter.base()); 14972 assert(ex == "-*********************0;0"); 14973 assert(ios.width() == 0); 14974 } 14975 } 14976 } 14977 showpoint(ios); 14978 { 14979 ios.imbue(lc); 14980 { 14981 ios.width(0); 14982 { 14983 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14984 std::string ex(str, iter.base()); 14985 assert(ex == "-0.0"); 14986 assert(ios.width() == 0); 14987 } 14988 ios.width(25); 14989 left(ios); 14990 { 14991 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14992 std::string ex(str, iter.base()); 14993 assert(ex == "-0.0*********************"); 14994 assert(ios.width() == 0); 14995 } 14996 ios.width(25); 14997 right(ios); 14998 { 14999 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15000 std::string ex(str, iter.base()); 15001 assert(ex == "*********************-0.0"); 15002 assert(ios.width() == 0); 15003 } 15004 ios.width(25); 15005 internal(ios); 15006 { 15007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15008 std::string ex(str, iter.base()); 15009 assert(ex == "-*********************0.0"); 15010 assert(ios.width() == 0); 15011 } 15012 } 15013 ios.imbue(lg); 15014 { 15015 ios.width(0); 15016 { 15017 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15018 std::string ex(str, iter.base()); 15019 assert(ex == "-0;0"); 15020 assert(ios.width() == 0); 15021 } 15022 ios.width(25); 15023 left(ios); 15024 { 15025 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15026 std::string ex(str, iter.base()); 15027 assert(ex == "-0;0*********************"); 15028 assert(ios.width() == 0); 15029 } 15030 ios.width(25); 15031 right(ios); 15032 { 15033 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15034 std::string ex(str, iter.base()); 15035 assert(ex == "*********************-0;0"); 15036 assert(ios.width() == 0); 15037 } 15038 ios.width(25); 15039 internal(ios); 15040 { 15041 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15042 std::string ex(str, iter.base()); 15043 assert(ex == "-*********************0;0"); 15044 assert(ios.width() == 0); 15045 } 15046 } 15047 } 15048 } 15049 showpos(ios); 15050 { 15051 noshowpoint(ios); 15052 { 15053 ios.imbue(lc); 15054 { 15055 ios.width(0); 15056 { 15057 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15058 std::string ex(str, iter.base()); 15059 assert(ex == "-0.0"); 15060 assert(ios.width() == 0); 15061 } 15062 ios.width(25); 15063 left(ios); 15064 { 15065 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15066 std::string ex(str, iter.base()); 15067 assert(ex == "-0.0*********************"); 15068 assert(ios.width() == 0); 15069 } 15070 ios.width(25); 15071 right(ios); 15072 { 15073 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15074 std::string ex(str, iter.base()); 15075 assert(ex == "*********************-0.0"); 15076 assert(ios.width() == 0); 15077 } 15078 ios.width(25); 15079 internal(ios); 15080 { 15081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15082 std::string ex(str, iter.base()); 15083 assert(ex == "-*********************0.0"); 15084 assert(ios.width() == 0); 15085 } 15086 } 15087 ios.imbue(lg); 15088 { 15089 ios.width(0); 15090 { 15091 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15092 std::string ex(str, iter.base()); 15093 assert(ex == "-0;0"); 15094 assert(ios.width() == 0); 15095 } 15096 ios.width(25); 15097 left(ios); 15098 { 15099 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15100 std::string ex(str, iter.base()); 15101 assert(ex == "-0;0*********************"); 15102 assert(ios.width() == 0); 15103 } 15104 ios.width(25); 15105 right(ios); 15106 { 15107 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15108 std::string ex(str, iter.base()); 15109 assert(ex == "*********************-0;0"); 15110 assert(ios.width() == 0); 15111 } 15112 ios.width(25); 15113 internal(ios); 15114 { 15115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15116 std::string ex(str, iter.base()); 15117 assert(ex == "-*********************0;0"); 15118 assert(ios.width() == 0); 15119 } 15120 } 15121 } 15122 showpoint(ios); 15123 { 15124 ios.imbue(lc); 15125 { 15126 ios.width(0); 15127 { 15128 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15129 std::string ex(str, iter.base()); 15130 assert(ex == "-0.0"); 15131 assert(ios.width() == 0); 15132 } 15133 ios.width(25); 15134 left(ios); 15135 { 15136 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15137 std::string ex(str, iter.base()); 15138 assert(ex == "-0.0*********************"); 15139 assert(ios.width() == 0); 15140 } 15141 ios.width(25); 15142 right(ios); 15143 { 15144 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15145 std::string ex(str, iter.base()); 15146 assert(ex == "*********************-0.0"); 15147 assert(ios.width() == 0); 15148 } 15149 ios.width(25); 15150 internal(ios); 15151 { 15152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15153 std::string ex(str, iter.base()); 15154 assert(ex == "-*********************0.0"); 15155 assert(ios.width() == 0); 15156 } 15157 } 15158 ios.imbue(lg); 15159 { 15160 ios.width(0); 15161 { 15162 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15163 std::string ex(str, iter.base()); 15164 assert(ex == "-0;0"); 15165 assert(ios.width() == 0); 15166 } 15167 ios.width(25); 15168 left(ios); 15169 { 15170 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15171 std::string ex(str, iter.base()); 15172 assert(ex == "-0;0*********************"); 15173 assert(ios.width() == 0); 15174 } 15175 ios.width(25); 15176 right(ios); 15177 { 15178 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15179 std::string ex(str, iter.base()); 15180 assert(ex == "*********************-0;0"); 15181 assert(ios.width() == 0); 15182 } 15183 ios.width(25); 15184 internal(ios); 15185 { 15186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15187 std::string ex(str, iter.base()); 15188 assert(ex == "-*********************0;0"); 15189 assert(ios.width() == 0); 15190 } 15191 } 15192 } 15193 } 15194 } 15195 uppercase(ios); 15196 { 15197 noshowpos(ios); 15198 { 15199 noshowpoint(ios); 15200 { 15201 ios.imbue(lc); 15202 { 15203 ios.width(0); 15204 { 15205 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15206 std::string ex(str, iter.base()); 15207 assert(ex == "-0.0"); 15208 assert(ios.width() == 0); 15209 } 15210 ios.width(25); 15211 left(ios); 15212 { 15213 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15214 std::string ex(str, iter.base()); 15215 assert(ex == "-0.0*********************"); 15216 assert(ios.width() == 0); 15217 } 15218 ios.width(25); 15219 right(ios); 15220 { 15221 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15222 std::string ex(str, iter.base()); 15223 assert(ex == "*********************-0.0"); 15224 assert(ios.width() == 0); 15225 } 15226 ios.width(25); 15227 internal(ios); 15228 { 15229 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15230 std::string ex(str, iter.base()); 15231 assert(ex == "-*********************0.0"); 15232 assert(ios.width() == 0); 15233 } 15234 } 15235 ios.imbue(lg); 15236 { 15237 ios.width(0); 15238 { 15239 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15240 std::string ex(str, iter.base()); 15241 assert(ex == "-0;0"); 15242 assert(ios.width() == 0); 15243 } 15244 ios.width(25); 15245 left(ios); 15246 { 15247 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15248 std::string ex(str, iter.base()); 15249 assert(ex == "-0;0*********************"); 15250 assert(ios.width() == 0); 15251 } 15252 ios.width(25); 15253 right(ios); 15254 { 15255 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15256 std::string ex(str, iter.base()); 15257 assert(ex == "*********************-0;0"); 15258 assert(ios.width() == 0); 15259 } 15260 ios.width(25); 15261 internal(ios); 15262 { 15263 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15264 std::string ex(str, iter.base()); 15265 assert(ex == "-*********************0;0"); 15266 assert(ios.width() == 0); 15267 } 15268 } 15269 } 15270 showpoint(ios); 15271 { 15272 ios.imbue(lc); 15273 { 15274 ios.width(0); 15275 { 15276 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15277 std::string ex(str, iter.base()); 15278 assert(ex == "-0.0"); 15279 assert(ios.width() == 0); 15280 } 15281 ios.width(25); 15282 left(ios); 15283 { 15284 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15285 std::string ex(str, iter.base()); 15286 assert(ex == "-0.0*********************"); 15287 assert(ios.width() == 0); 15288 } 15289 ios.width(25); 15290 right(ios); 15291 { 15292 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15293 std::string ex(str, iter.base()); 15294 assert(ex == "*********************-0.0"); 15295 assert(ios.width() == 0); 15296 } 15297 ios.width(25); 15298 internal(ios); 15299 { 15300 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15301 std::string ex(str, iter.base()); 15302 assert(ex == "-*********************0.0"); 15303 assert(ios.width() == 0); 15304 } 15305 } 15306 ios.imbue(lg); 15307 { 15308 ios.width(0); 15309 { 15310 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15311 std::string ex(str, iter.base()); 15312 assert(ex == "-0;0"); 15313 assert(ios.width() == 0); 15314 } 15315 ios.width(25); 15316 left(ios); 15317 { 15318 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15319 std::string ex(str, iter.base()); 15320 assert(ex == "-0;0*********************"); 15321 assert(ios.width() == 0); 15322 } 15323 ios.width(25); 15324 right(ios); 15325 { 15326 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15327 std::string ex(str, iter.base()); 15328 assert(ex == "*********************-0;0"); 15329 assert(ios.width() == 0); 15330 } 15331 ios.width(25); 15332 internal(ios); 15333 { 15334 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15335 std::string ex(str, iter.base()); 15336 assert(ex == "-*********************0;0"); 15337 assert(ios.width() == 0); 15338 } 15339 } 15340 } 15341 } 15342 showpos(ios); 15343 { 15344 noshowpoint(ios); 15345 { 15346 ios.imbue(lc); 15347 { 15348 ios.width(0); 15349 { 15350 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15351 std::string ex(str, iter.base()); 15352 assert(ex == "-0.0"); 15353 assert(ios.width() == 0); 15354 } 15355 ios.width(25); 15356 left(ios); 15357 { 15358 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15359 std::string ex(str, iter.base()); 15360 assert(ex == "-0.0*********************"); 15361 assert(ios.width() == 0); 15362 } 15363 ios.width(25); 15364 right(ios); 15365 { 15366 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15367 std::string ex(str, iter.base()); 15368 assert(ex == "*********************-0.0"); 15369 assert(ios.width() == 0); 15370 } 15371 ios.width(25); 15372 internal(ios); 15373 { 15374 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15375 std::string ex(str, iter.base()); 15376 assert(ex == "-*********************0.0"); 15377 assert(ios.width() == 0); 15378 } 15379 } 15380 ios.imbue(lg); 15381 { 15382 ios.width(0); 15383 { 15384 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15385 std::string ex(str, iter.base()); 15386 assert(ex == "-0;0"); 15387 assert(ios.width() == 0); 15388 } 15389 ios.width(25); 15390 left(ios); 15391 { 15392 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15393 std::string ex(str, iter.base()); 15394 assert(ex == "-0;0*********************"); 15395 assert(ios.width() == 0); 15396 } 15397 ios.width(25); 15398 right(ios); 15399 { 15400 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15401 std::string ex(str, iter.base()); 15402 assert(ex == "*********************-0;0"); 15403 assert(ios.width() == 0); 15404 } 15405 ios.width(25); 15406 internal(ios); 15407 { 15408 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15409 std::string ex(str, iter.base()); 15410 assert(ex == "-*********************0;0"); 15411 assert(ios.width() == 0); 15412 } 15413 } 15414 } 15415 showpoint(ios); 15416 { 15417 ios.imbue(lc); 15418 { 15419 ios.width(0); 15420 { 15421 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15422 std::string ex(str, iter.base()); 15423 assert(ex == "-0.0"); 15424 assert(ios.width() == 0); 15425 } 15426 ios.width(25); 15427 left(ios); 15428 { 15429 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15430 std::string ex(str, iter.base()); 15431 assert(ex == "-0.0*********************"); 15432 assert(ios.width() == 0); 15433 } 15434 ios.width(25); 15435 right(ios); 15436 { 15437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15438 std::string ex(str, iter.base()); 15439 assert(ex == "*********************-0.0"); 15440 assert(ios.width() == 0); 15441 } 15442 ios.width(25); 15443 internal(ios); 15444 { 15445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15446 std::string ex(str, iter.base()); 15447 assert(ex == "-*********************0.0"); 15448 assert(ios.width() == 0); 15449 } 15450 } 15451 ios.imbue(lg); 15452 { 15453 ios.width(0); 15454 { 15455 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15456 std::string ex(str, iter.base()); 15457 assert(ex == "-0;0"); 15458 assert(ios.width() == 0); 15459 } 15460 ios.width(25); 15461 left(ios); 15462 { 15463 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15464 std::string ex(str, iter.base()); 15465 assert(ex == "-0;0*********************"); 15466 assert(ios.width() == 0); 15467 } 15468 ios.width(25); 15469 right(ios); 15470 { 15471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15472 std::string ex(str, iter.base()); 15473 assert(ex == "*********************-0;0"); 15474 assert(ios.width() == 0); 15475 } 15476 ios.width(25); 15477 internal(ios); 15478 { 15479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15480 std::string ex(str, iter.base()); 15481 assert(ex == "-*********************0;0"); 15482 assert(ios.width() == 0); 15483 } 15484 } 15485 } 15486 } 15487 } 15488 } 15489 ios.precision(6); 15490 { 15491 nouppercase(ios); 15492 { 15493 noshowpos(ios); 15494 { 15495 noshowpoint(ios); 15496 { 15497 ios.imbue(lc); 15498 { 15499 ios.width(0); 15500 { 15501 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15502 std::string ex(str, iter.base()); 15503 assert(ex == "-0.000000"); 15504 assert(ios.width() == 0); 15505 } 15506 ios.width(25); 15507 left(ios); 15508 { 15509 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15510 std::string ex(str, iter.base()); 15511 assert(ex == "-0.000000****************"); 15512 assert(ios.width() == 0); 15513 } 15514 ios.width(25); 15515 right(ios); 15516 { 15517 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15518 std::string ex(str, iter.base()); 15519 assert(ex == "****************-0.000000"); 15520 assert(ios.width() == 0); 15521 } 15522 ios.width(25); 15523 internal(ios); 15524 { 15525 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15526 std::string ex(str, iter.base()); 15527 assert(ex == "-****************0.000000"); 15528 assert(ios.width() == 0); 15529 } 15530 } 15531 ios.imbue(lg); 15532 { 15533 ios.width(0); 15534 { 15535 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15536 std::string ex(str, iter.base()); 15537 assert(ex == "-0;000000"); 15538 assert(ios.width() == 0); 15539 } 15540 ios.width(25); 15541 left(ios); 15542 { 15543 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15544 std::string ex(str, iter.base()); 15545 assert(ex == "-0;000000****************"); 15546 assert(ios.width() == 0); 15547 } 15548 ios.width(25); 15549 right(ios); 15550 { 15551 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15552 std::string ex(str, iter.base()); 15553 assert(ex == "****************-0;000000"); 15554 assert(ios.width() == 0); 15555 } 15556 ios.width(25); 15557 internal(ios); 15558 { 15559 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15560 std::string ex(str, iter.base()); 15561 assert(ex == "-****************0;000000"); 15562 assert(ios.width() == 0); 15563 } 15564 } 15565 } 15566 showpoint(ios); 15567 { 15568 ios.imbue(lc); 15569 { 15570 ios.width(0); 15571 { 15572 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15573 std::string ex(str, iter.base()); 15574 assert(ex == "-0.000000"); 15575 assert(ios.width() == 0); 15576 } 15577 ios.width(25); 15578 left(ios); 15579 { 15580 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15581 std::string ex(str, iter.base()); 15582 assert(ex == "-0.000000****************"); 15583 assert(ios.width() == 0); 15584 } 15585 ios.width(25); 15586 right(ios); 15587 { 15588 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15589 std::string ex(str, iter.base()); 15590 assert(ex == "****************-0.000000"); 15591 assert(ios.width() == 0); 15592 } 15593 ios.width(25); 15594 internal(ios); 15595 { 15596 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15597 std::string ex(str, iter.base()); 15598 assert(ex == "-****************0.000000"); 15599 assert(ios.width() == 0); 15600 } 15601 } 15602 ios.imbue(lg); 15603 { 15604 ios.width(0); 15605 { 15606 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15607 std::string ex(str, iter.base()); 15608 assert(ex == "-0;000000"); 15609 assert(ios.width() == 0); 15610 } 15611 ios.width(25); 15612 left(ios); 15613 { 15614 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15615 std::string ex(str, iter.base()); 15616 assert(ex == "-0;000000****************"); 15617 assert(ios.width() == 0); 15618 } 15619 ios.width(25); 15620 right(ios); 15621 { 15622 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15623 std::string ex(str, iter.base()); 15624 assert(ex == "****************-0;000000"); 15625 assert(ios.width() == 0); 15626 } 15627 ios.width(25); 15628 internal(ios); 15629 { 15630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15631 std::string ex(str, iter.base()); 15632 assert(ex == "-****************0;000000"); 15633 assert(ios.width() == 0); 15634 } 15635 } 15636 } 15637 } 15638 showpos(ios); 15639 { 15640 noshowpoint(ios); 15641 { 15642 ios.imbue(lc); 15643 { 15644 ios.width(0); 15645 { 15646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15647 std::string ex(str, iter.base()); 15648 assert(ex == "-0.000000"); 15649 assert(ios.width() == 0); 15650 } 15651 ios.width(25); 15652 left(ios); 15653 { 15654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15655 std::string ex(str, iter.base()); 15656 assert(ex == "-0.000000****************"); 15657 assert(ios.width() == 0); 15658 } 15659 ios.width(25); 15660 right(ios); 15661 { 15662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15663 std::string ex(str, iter.base()); 15664 assert(ex == "****************-0.000000"); 15665 assert(ios.width() == 0); 15666 } 15667 ios.width(25); 15668 internal(ios); 15669 { 15670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15671 std::string ex(str, iter.base()); 15672 assert(ex == "-****************0.000000"); 15673 assert(ios.width() == 0); 15674 } 15675 } 15676 ios.imbue(lg); 15677 { 15678 ios.width(0); 15679 { 15680 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15681 std::string ex(str, iter.base()); 15682 assert(ex == "-0;000000"); 15683 assert(ios.width() == 0); 15684 } 15685 ios.width(25); 15686 left(ios); 15687 { 15688 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15689 std::string ex(str, iter.base()); 15690 assert(ex == "-0;000000****************"); 15691 assert(ios.width() == 0); 15692 } 15693 ios.width(25); 15694 right(ios); 15695 { 15696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15697 std::string ex(str, iter.base()); 15698 assert(ex == "****************-0;000000"); 15699 assert(ios.width() == 0); 15700 } 15701 ios.width(25); 15702 internal(ios); 15703 { 15704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15705 std::string ex(str, iter.base()); 15706 assert(ex == "-****************0;000000"); 15707 assert(ios.width() == 0); 15708 } 15709 } 15710 } 15711 showpoint(ios); 15712 { 15713 ios.imbue(lc); 15714 { 15715 ios.width(0); 15716 { 15717 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15718 std::string ex(str, iter.base()); 15719 assert(ex == "-0.000000"); 15720 assert(ios.width() == 0); 15721 } 15722 ios.width(25); 15723 left(ios); 15724 { 15725 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15726 std::string ex(str, iter.base()); 15727 assert(ex == "-0.000000****************"); 15728 assert(ios.width() == 0); 15729 } 15730 ios.width(25); 15731 right(ios); 15732 { 15733 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15734 std::string ex(str, iter.base()); 15735 assert(ex == "****************-0.000000"); 15736 assert(ios.width() == 0); 15737 } 15738 ios.width(25); 15739 internal(ios); 15740 { 15741 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15742 std::string ex(str, iter.base()); 15743 assert(ex == "-****************0.000000"); 15744 assert(ios.width() == 0); 15745 } 15746 } 15747 ios.imbue(lg); 15748 { 15749 ios.width(0); 15750 { 15751 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15752 std::string ex(str, iter.base()); 15753 assert(ex == "-0;000000"); 15754 assert(ios.width() == 0); 15755 } 15756 ios.width(25); 15757 left(ios); 15758 { 15759 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15760 std::string ex(str, iter.base()); 15761 assert(ex == "-0;000000****************"); 15762 assert(ios.width() == 0); 15763 } 15764 ios.width(25); 15765 right(ios); 15766 { 15767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15768 std::string ex(str, iter.base()); 15769 assert(ex == "****************-0;000000"); 15770 assert(ios.width() == 0); 15771 } 15772 ios.width(25); 15773 internal(ios); 15774 { 15775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15776 std::string ex(str, iter.base()); 15777 assert(ex == "-****************0;000000"); 15778 assert(ios.width() == 0); 15779 } 15780 } 15781 } 15782 } 15783 } 15784 uppercase(ios); 15785 { 15786 noshowpos(ios); 15787 { 15788 noshowpoint(ios); 15789 { 15790 ios.imbue(lc); 15791 { 15792 ios.width(0); 15793 { 15794 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15795 std::string ex(str, iter.base()); 15796 assert(ex == "-0.000000"); 15797 assert(ios.width() == 0); 15798 } 15799 ios.width(25); 15800 left(ios); 15801 { 15802 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15803 std::string ex(str, iter.base()); 15804 assert(ex == "-0.000000****************"); 15805 assert(ios.width() == 0); 15806 } 15807 ios.width(25); 15808 right(ios); 15809 { 15810 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15811 std::string ex(str, iter.base()); 15812 assert(ex == "****************-0.000000"); 15813 assert(ios.width() == 0); 15814 } 15815 ios.width(25); 15816 internal(ios); 15817 { 15818 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15819 std::string ex(str, iter.base()); 15820 assert(ex == "-****************0.000000"); 15821 assert(ios.width() == 0); 15822 } 15823 } 15824 ios.imbue(lg); 15825 { 15826 ios.width(0); 15827 { 15828 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15829 std::string ex(str, iter.base()); 15830 assert(ex == "-0;000000"); 15831 assert(ios.width() == 0); 15832 } 15833 ios.width(25); 15834 left(ios); 15835 { 15836 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15837 std::string ex(str, iter.base()); 15838 assert(ex == "-0;000000****************"); 15839 assert(ios.width() == 0); 15840 } 15841 ios.width(25); 15842 right(ios); 15843 { 15844 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15845 std::string ex(str, iter.base()); 15846 assert(ex == "****************-0;000000"); 15847 assert(ios.width() == 0); 15848 } 15849 ios.width(25); 15850 internal(ios); 15851 { 15852 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15853 std::string ex(str, iter.base()); 15854 assert(ex == "-****************0;000000"); 15855 assert(ios.width() == 0); 15856 } 15857 } 15858 } 15859 showpoint(ios); 15860 { 15861 ios.imbue(lc); 15862 { 15863 ios.width(0); 15864 { 15865 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15866 std::string ex(str, iter.base()); 15867 assert(ex == "-0.000000"); 15868 assert(ios.width() == 0); 15869 } 15870 ios.width(25); 15871 left(ios); 15872 { 15873 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15874 std::string ex(str, iter.base()); 15875 assert(ex == "-0.000000****************"); 15876 assert(ios.width() == 0); 15877 } 15878 ios.width(25); 15879 right(ios); 15880 { 15881 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15882 std::string ex(str, iter.base()); 15883 assert(ex == "****************-0.000000"); 15884 assert(ios.width() == 0); 15885 } 15886 ios.width(25); 15887 internal(ios); 15888 { 15889 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15890 std::string ex(str, iter.base()); 15891 assert(ex == "-****************0.000000"); 15892 assert(ios.width() == 0); 15893 } 15894 } 15895 ios.imbue(lg); 15896 { 15897 ios.width(0); 15898 { 15899 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15900 std::string ex(str, iter.base()); 15901 assert(ex == "-0;000000"); 15902 assert(ios.width() == 0); 15903 } 15904 ios.width(25); 15905 left(ios); 15906 { 15907 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15908 std::string ex(str, iter.base()); 15909 assert(ex == "-0;000000****************"); 15910 assert(ios.width() == 0); 15911 } 15912 ios.width(25); 15913 right(ios); 15914 { 15915 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15916 std::string ex(str, iter.base()); 15917 assert(ex == "****************-0;000000"); 15918 assert(ios.width() == 0); 15919 } 15920 ios.width(25); 15921 internal(ios); 15922 { 15923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15924 std::string ex(str, iter.base()); 15925 assert(ex == "-****************0;000000"); 15926 assert(ios.width() == 0); 15927 } 15928 } 15929 } 15930 } 15931 showpos(ios); 15932 { 15933 noshowpoint(ios); 15934 { 15935 ios.imbue(lc); 15936 { 15937 ios.width(0); 15938 { 15939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15940 std::string ex(str, iter.base()); 15941 assert(ex == "-0.000000"); 15942 assert(ios.width() == 0); 15943 } 15944 ios.width(25); 15945 left(ios); 15946 { 15947 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15948 std::string ex(str, iter.base()); 15949 assert(ex == "-0.000000****************"); 15950 assert(ios.width() == 0); 15951 } 15952 ios.width(25); 15953 right(ios); 15954 { 15955 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15956 std::string ex(str, iter.base()); 15957 assert(ex == "****************-0.000000"); 15958 assert(ios.width() == 0); 15959 } 15960 ios.width(25); 15961 internal(ios); 15962 { 15963 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15964 std::string ex(str, iter.base()); 15965 assert(ex == "-****************0.000000"); 15966 assert(ios.width() == 0); 15967 } 15968 } 15969 ios.imbue(lg); 15970 { 15971 ios.width(0); 15972 { 15973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15974 std::string ex(str, iter.base()); 15975 assert(ex == "-0;000000"); 15976 assert(ios.width() == 0); 15977 } 15978 ios.width(25); 15979 left(ios); 15980 { 15981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15982 std::string ex(str, iter.base()); 15983 assert(ex == "-0;000000****************"); 15984 assert(ios.width() == 0); 15985 } 15986 ios.width(25); 15987 right(ios); 15988 { 15989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15990 std::string ex(str, iter.base()); 15991 assert(ex == "****************-0;000000"); 15992 assert(ios.width() == 0); 15993 } 15994 ios.width(25); 15995 internal(ios); 15996 { 15997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15998 std::string ex(str, iter.base()); 15999 assert(ex == "-****************0;000000"); 16000 assert(ios.width() == 0); 16001 } 16002 } 16003 } 16004 showpoint(ios); 16005 { 16006 ios.imbue(lc); 16007 { 16008 ios.width(0); 16009 { 16010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16011 std::string ex(str, iter.base()); 16012 assert(ex == "-0.000000"); 16013 assert(ios.width() == 0); 16014 } 16015 ios.width(25); 16016 left(ios); 16017 { 16018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16019 std::string ex(str, iter.base()); 16020 assert(ex == "-0.000000****************"); 16021 assert(ios.width() == 0); 16022 } 16023 ios.width(25); 16024 right(ios); 16025 { 16026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16027 std::string ex(str, iter.base()); 16028 assert(ex == "****************-0.000000"); 16029 assert(ios.width() == 0); 16030 } 16031 ios.width(25); 16032 internal(ios); 16033 { 16034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16035 std::string ex(str, iter.base()); 16036 assert(ex == "-****************0.000000"); 16037 assert(ios.width() == 0); 16038 } 16039 } 16040 ios.imbue(lg); 16041 { 16042 ios.width(0); 16043 { 16044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16045 std::string ex(str, iter.base()); 16046 assert(ex == "-0;000000"); 16047 assert(ios.width() == 0); 16048 } 16049 ios.width(25); 16050 left(ios); 16051 { 16052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16053 std::string ex(str, iter.base()); 16054 assert(ex == "-0;000000****************"); 16055 assert(ios.width() == 0); 16056 } 16057 ios.width(25); 16058 right(ios); 16059 { 16060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16061 std::string ex(str, iter.base()); 16062 assert(ex == "****************-0;000000"); 16063 assert(ios.width() == 0); 16064 } 16065 ios.width(25); 16066 internal(ios); 16067 { 16068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16069 std::string ex(str, iter.base()); 16070 assert(ex == "-****************0;000000"); 16071 assert(ios.width() == 0); 16072 } 16073 } 16074 } 16075 } 16076 } 16077 } 16078 ios.precision(16); 16079 { 16080 nouppercase(ios); 16081 { 16082 noshowpos(ios); 16083 { 16084 noshowpoint(ios); 16085 { 16086 ios.imbue(lc); 16087 { 16088 ios.width(0); 16089 { 16090 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16091 std::string ex(str, iter.base()); 16092 assert(ex == "-0.0000000000000000"); 16093 assert(ios.width() == 0); 16094 } 16095 ios.width(25); 16096 left(ios); 16097 { 16098 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16099 std::string ex(str, iter.base()); 16100 assert(ex == "-0.0000000000000000******"); 16101 assert(ios.width() == 0); 16102 } 16103 ios.width(25); 16104 right(ios); 16105 { 16106 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16107 std::string ex(str, iter.base()); 16108 assert(ex == "******-0.0000000000000000"); 16109 assert(ios.width() == 0); 16110 } 16111 ios.width(25); 16112 internal(ios); 16113 { 16114 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16115 std::string ex(str, iter.base()); 16116 assert(ex == "-******0.0000000000000000"); 16117 assert(ios.width() == 0); 16118 } 16119 } 16120 ios.imbue(lg); 16121 { 16122 ios.width(0); 16123 { 16124 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16125 std::string ex(str, iter.base()); 16126 assert(ex == "-0;0000000000000000"); 16127 assert(ios.width() == 0); 16128 } 16129 ios.width(25); 16130 left(ios); 16131 { 16132 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16133 std::string ex(str, iter.base()); 16134 assert(ex == "-0;0000000000000000******"); 16135 assert(ios.width() == 0); 16136 } 16137 ios.width(25); 16138 right(ios); 16139 { 16140 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16141 std::string ex(str, iter.base()); 16142 assert(ex == "******-0;0000000000000000"); 16143 assert(ios.width() == 0); 16144 } 16145 ios.width(25); 16146 internal(ios); 16147 { 16148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16149 std::string ex(str, iter.base()); 16150 assert(ex == "-******0;0000000000000000"); 16151 assert(ios.width() == 0); 16152 } 16153 } 16154 } 16155 showpoint(ios); 16156 { 16157 ios.imbue(lc); 16158 { 16159 ios.width(0); 16160 { 16161 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16162 std::string ex(str, iter.base()); 16163 assert(ex == "-0.0000000000000000"); 16164 assert(ios.width() == 0); 16165 } 16166 ios.width(25); 16167 left(ios); 16168 { 16169 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16170 std::string ex(str, iter.base()); 16171 assert(ex == "-0.0000000000000000******"); 16172 assert(ios.width() == 0); 16173 } 16174 ios.width(25); 16175 right(ios); 16176 { 16177 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16178 std::string ex(str, iter.base()); 16179 assert(ex == "******-0.0000000000000000"); 16180 assert(ios.width() == 0); 16181 } 16182 ios.width(25); 16183 internal(ios); 16184 { 16185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16186 std::string ex(str, iter.base()); 16187 assert(ex == "-******0.0000000000000000"); 16188 assert(ios.width() == 0); 16189 } 16190 } 16191 ios.imbue(lg); 16192 { 16193 ios.width(0); 16194 { 16195 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16196 std::string ex(str, iter.base()); 16197 assert(ex == "-0;0000000000000000"); 16198 assert(ios.width() == 0); 16199 } 16200 ios.width(25); 16201 left(ios); 16202 { 16203 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16204 std::string ex(str, iter.base()); 16205 assert(ex == "-0;0000000000000000******"); 16206 assert(ios.width() == 0); 16207 } 16208 ios.width(25); 16209 right(ios); 16210 { 16211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16212 std::string ex(str, iter.base()); 16213 assert(ex == "******-0;0000000000000000"); 16214 assert(ios.width() == 0); 16215 } 16216 ios.width(25); 16217 internal(ios); 16218 { 16219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16220 std::string ex(str, iter.base()); 16221 assert(ex == "-******0;0000000000000000"); 16222 assert(ios.width() == 0); 16223 } 16224 } 16225 } 16226 } 16227 showpos(ios); 16228 { 16229 noshowpoint(ios); 16230 { 16231 ios.imbue(lc); 16232 { 16233 ios.width(0); 16234 { 16235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16236 std::string ex(str, iter.base()); 16237 assert(ex == "-0.0000000000000000"); 16238 assert(ios.width() == 0); 16239 } 16240 ios.width(25); 16241 left(ios); 16242 { 16243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16244 std::string ex(str, iter.base()); 16245 assert(ex == "-0.0000000000000000******"); 16246 assert(ios.width() == 0); 16247 } 16248 ios.width(25); 16249 right(ios); 16250 { 16251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16252 std::string ex(str, iter.base()); 16253 assert(ex == "******-0.0000000000000000"); 16254 assert(ios.width() == 0); 16255 } 16256 ios.width(25); 16257 internal(ios); 16258 { 16259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16260 std::string ex(str, iter.base()); 16261 assert(ex == "-******0.0000000000000000"); 16262 assert(ios.width() == 0); 16263 } 16264 } 16265 ios.imbue(lg); 16266 { 16267 ios.width(0); 16268 { 16269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16270 std::string ex(str, iter.base()); 16271 assert(ex == "-0;0000000000000000"); 16272 assert(ios.width() == 0); 16273 } 16274 ios.width(25); 16275 left(ios); 16276 { 16277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16278 std::string ex(str, iter.base()); 16279 assert(ex == "-0;0000000000000000******"); 16280 assert(ios.width() == 0); 16281 } 16282 ios.width(25); 16283 right(ios); 16284 { 16285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16286 std::string ex(str, iter.base()); 16287 assert(ex == "******-0;0000000000000000"); 16288 assert(ios.width() == 0); 16289 } 16290 ios.width(25); 16291 internal(ios); 16292 { 16293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16294 std::string ex(str, iter.base()); 16295 assert(ex == "-******0;0000000000000000"); 16296 assert(ios.width() == 0); 16297 } 16298 } 16299 } 16300 showpoint(ios); 16301 { 16302 ios.imbue(lc); 16303 { 16304 ios.width(0); 16305 { 16306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16307 std::string ex(str, iter.base()); 16308 assert(ex == "-0.0000000000000000"); 16309 assert(ios.width() == 0); 16310 } 16311 ios.width(25); 16312 left(ios); 16313 { 16314 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16315 std::string ex(str, iter.base()); 16316 assert(ex == "-0.0000000000000000******"); 16317 assert(ios.width() == 0); 16318 } 16319 ios.width(25); 16320 right(ios); 16321 { 16322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16323 std::string ex(str, iter.base()); 16324 assert(ex == "******-0.0000000000000000"); 16325 assert(ios.width() == 0); 16326 } 16327 ios.width(25); 16328 internal(ios); 16329 { 16330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16331 std::string ex(str, iter.base()); 16332 assert(ex == "-******0.0000000000000000"); 16333 assert(ios.width() == 0); 16334 } 16335 } 16336 ios.imbue(lg); 16337 { 16338 ios.width(0); 16339 { 16340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16341 std::string ex(str, iter.base()); 16342 assert(ex == "-0;0000000000000000"); 16343 assert(ios.width() == 0); 16344 } 16345 ios.width(25); 16346 left(ios); 16347 { 16348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16349 std::string ex(str, iter.base()); 16350 assert(ex == "-0;0000000000000000******"); 16351 assert(ios.width() == 0); 16352 } 16353 ios.width(25); 16354 right(ios); 16355 { 16356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16357 std::string ex(str, iter.base()); 16358 assert(ex == "******-0;0000000000000000"); 16359 assert(ios.width() == 0); 16360 } 16361 ios.width(25); 16362 internal(ios); 16363 { 16364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16365 std::string ex(str, iter.base()); 16366 assert(ex == "-******0;0000000000000000"); 16367 assert(ios.width() == 0); 16368 } 16369 } 16370 } 16371 } 16372 } 16373 uppercase(ios); 16374 { 16375 noshowpos(ios); 16376 { 16377 noshowpoint(ios); 16378 { 16379 ios.imbue(lc); 16380 { 16381 ios.width(0); 16382 { 16383 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16384 std::string ex(str, iter.base()); 16385 assert(ex == "-0.0000000000000000"); 16386 assert(ios.width() == 0); 16387 } 16388 ios.width(25); 16389 left(ios); 16390 { 16391 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16392 std::string ex(str, iter.base()); 16393 assert(ex == "-0.0000000000000000******"); 16394 assert(ios.width() == 0); 16395 } 16396 ios.width(25); 16397 right(ios); 16398 { 16399 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16400 std::string ex(str, iter.base()); 16401 assert(ex == "******-0.0000000000000000"); 16402 assert(ios.width() == 0); 16403 } 16404 ios.width(25); 16405 internal(ios); 16406 { 16407 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16408 std::string ex(str, iter.base()); 16409 assert(ex == "-******0.0000000000000000"); 16410 assert(ios.width() == 0); 16411 } 16412 } 16413 ios.imbue(lg); 16414 { 16415 ios.width(0); 16416 { 16417 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16418 std::string ex(str, iter.base()); 16419 assert(ex == "-0;0000000000000000"); 16420 assert(ios.width() == 0); 16421 } 16422 ios.width(25); 16423 left(ios); 16424 { 16425 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16426 std::string ex(str, iter.base()); 16427 assert(ex == "-0;0000000000000000******"); 16428 assert(ios.width() == 0); 16429 } 16430 ios.width(25); 16431 right(ios); 16432 { 16433 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16434 std::string ex(str, iter.base()); 16435 assert(ex == "******-0;0000000000000000"); 16436 assert(ios.width() == 0); 16437 } 16438 ios.width(25); 16439 internal(ios); 16440 { 16441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16442 std::string ex(str, iter.base()); 16443 assert(ex == "-******0;0000000000000000"); 16444 assert(ios.width() == 0); 16445 } 16446 } 16447 } 16448 showpoint(ios); 16449 { 16450 ios.imbue(lc); 16451 { 16452 ios.width(0); 16453 { 16454 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16455 std::string ex(str, iter.base()); 16456 assert(ex == "-0.0000000000000000"); 16457 assert(ios.width() == 0); 16458 } 16459 ios.width(25); 16460 left(ios); 16461 { 16462 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16463 std::string ex(str, iter.base()); 16464 assert(ex == "-0.0000000000000000******"); 16465 assert(ios.width() == 0); 16466 } 16467 ios.width(25); 16468 right(ios); 16469 { 16470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16471 std::string ex(str, iter.base()); 16472 assert(ex == "******-0.0000000000000000"); 16473 assert(ios.width() == 0); 16474 } 16475 ios.width(25); 16476 internal(ios); 16477 { 16478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16479 std::string ex(str, iter.base()); 16480 assert(ex == "-******0.0000000000000000"); 16481 assert(ios.width() == 0); 16482 } 16483 } 16484 ios.imbue(lg); 16485 { 16486 ios.width(0); 16487 { 16488 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16489 std::string ex(str, iter.base()); 16490 assert(ex == "-0;0000000000000000"); 16491 assert(ios.width() == 0); 16492 } 16493 ios.width(25); 16494 left(ios); 16495 { 16496 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16497 std::string ex(str, iter.base()); 16498 assert(ex == "-0;0000000000000000******"); 16499 assert(ios.width() == 0); 16500 } 16501 ios.width(25); 16502 right(ios); 16503 { 16504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16505 std::string ex(str, iter.base()); 16506 assert(ex == "******-0;0000000000000000"); 16507 assert(ios.width() == 0); 16508 } 16509 ios.width(25); 16510 internal(ios); 16511 { 16512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16513 std::string ex(str, iter.base()); 16514 assert(ex == "-******0;0000000000000000"); 16515 assert(ios.width() == 0); 16516 } 16517 } 16518 } 16519 } 16520 showpos(ios); 16521 { 16522 noshowpoint(ios); 16523 { 16524 ios.imbue(lc); 16525 { 16526 ios.width(0); 16527 { 16528 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16529 std::string ex(str, iter.base()); 16530 assert(ex == "-0.0000000000000000"); 16531 assert(ios.width() == 0); 16532 } 16533 ios.width(25); 16534 left(ios); 16535 { 16536 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16537 std::string ex(str, iter.base()); 16538 assert(ex == "-0.0000000000000000******"); 16539 assert(ios.width() == 0); 16540 } 16541 ios.width(25); 16542 right(ios); 16543 { 16544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16545 std::string ex(str, iter.base()); 16546 assert(ex == "******-0.0000000000000000"); 16547 assert(ios.width() == 0); 16548 } 16549 ios.width(25); 16550 internal(ios); 16551 { 16552 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16553 std::string ex(str, iter.base()); 16554 assert(ex == "-******0.0000000000000000"); 16555 assert(ios.width() == 0); 16556 } 16557 } 16558 ios.imbue(lg); 16559 { 16560 ios.width(0); 16561 { 16562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16563 std::string ex(str, iter.base()); 16564 assert(ex == "-0;0000000000000000"); 16565 assert(ios.width() == 0); 16566 } 16567 ios.width(25); 16568 left(ios); 16569 { 16570 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16571 std::string ex(str, iter.base()); 16572 assert(ex == "-0;0000000000000000******"); 16573 assert(ios.width() == 0); 16574 } 16575 ios.width(25); 16576 right(ios); 16577 { 16578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16579 std::string ex(str, iter.base()); 16580 assert(ex == "******-0;0000000000000000"); 16581 assert(ios.width() == 0); 16582 } 16583 ios.width(25); 16584 internal(ios); 16585 { 16586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16587 std::string ex(str, iter.base()); 16588 assert(ex == "-******0;0000000000000000"); 16589 assert(ios.width() == 0); 16590 } 16591 } 16592 } 16593 showpoint(ios); 16594 { 16595 ios.imbue(lc); 16596 { 16597 ios.width(0); 16598 { 16599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16600 std::string ex(str, iter.base()); 16601 assert(ex == "-0.0000000000000000"); 16602 assert(ios.width() == 0); 16603 } 16604 ios.width(25); 16605 left(ios); 16606 { 16607 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16608 std::string ex(str, iter.base()); 16609 assert(ex == "-0.0000000000000000******"); 16610 assert(ios.width() == 0); 16611 } 16612 ios.width(25); 16613 right(ios); 16614 { 16615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16616 std::string ex(str, iter.base()); 16617 assert(ex == "******-0.0000000000000000"); 16618 assert(ios.width() == 0); 16619 } 16620 ios.width(25); 16621 internal(ios); 16622 { 16623 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16624 std::string ex(str, iter.base()); 16625 assert(ex == "-******0.0000000000000000"); 16626 assert(ios.width() == 0); 16627 } 16628 } 16629 ios.imbue(lg); 16630 { 16631 ios.width(0); 16632 { 16633 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16634 std::string ex(str, iter.base()); 16635 assert(ex == "-0;0000000000000000"); 16636 assert(ios.width() == 0); 16637 } 16638 ios.width(25); 16639 left(ios); 16640 { 16641 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16642 std::string ex(str, iter.base()); 16643 assert(ex == "-0;0000000000000000******"); 16644 assert(ios.width() == 0); 16645 } 16646 ios.width(25); 16647 right(ios); 16648 { 16649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16650 std::string ex(str, iter.base()); 16651 assert(ex == "******-0;0000000000000000"); 16652 assert(ios.width() == 0); 16653 } 16654 ios.width(25); 16655 internal(ios); 16656 { 16657 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16658 std::string ex(str, iter.base()); 16659 assert(ex == "-******0;0000000000000000"); 16660 assert(ios.width() == 0); 16661 } 16662 } 16663 } 16664 } 16665 } 16666 } 16667 ios.precision(60); 16668 { 16669 nouppercase(ios); 16670 { 16671 noshowpos(ios); 16672 { 16673 noshowpoint(ios); 16674 { 16675 ios.imbue(lc); 16676 { 16677 ios.width(0); 16678 { 16679 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16680 std::string ex(str, iter.base()); 16681 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16682 assert(ios.width() == 0); 16683 } 16684 ios.width(25); 16685 left(ios); 16686 { 16687 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16688 std::string ex(str, iter.base()); 16689 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16690 assert(ios.width() == 0); 16691 } 16692 ios.width(25); 16693 right(ios); 16694 { 16695 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16696 std::string ex(str, iter.base()); 16697 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16698 assert(ios.width() == 0); 16699 } 16700 ios.width(25); 16701 internal(ios); 16702 { 16703 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16704 std::string ex(str, iter.base()); 16705 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16706 assert(ios.width() == 0); 16707 } 16708 } 16709 ios.imbue(lg); 16710 { 16711 ios.width(0); 16712 { 16713 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16714 std::string ex(str, iter.base()); 16715 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16716 assert(ios.width() == 0); 16717 } 16718 ios.width(25); 16719 left(ios); 16720 { 16721 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16722 std::string ex(str, iter.base()); 16723 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16724 assert(ios.width() == 0); 16725 } 16726 ios.width(25); 16727 right(ios); 16728 { 16729 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16730 std::string ex(str, iter.base()); 16731 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16732 assert(ios.width() == 0); 16733 } 16734 ios.width(25); 16735 internal(ios); 16736 { 16737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16738 std::string ex(str, iter.base()); 16739 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16740 assert(ios.width() == 0); 16741 } 16742 } 16743 } 16744 showpoint(ios); 16745 { 16746 ios.imbue(lc); 16747 { 16748 ios.width(0); 16749 { 16750 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16751 std::string ex(str, iter.base()); 16752 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16753 assert(ios.width() == 0); 16754 } 16755 ios.width(25); 16756 left(ios); 16757 { 16758 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16759 std::string ex(str, iter.base()); 16760 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16761 assert(ios.width() == 0); 16762 } 16763 ios.width(25); 16764 right(ios); 16765 { 16766 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16767 std::string ex(str, iter.base()); 16768 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16769 assert(ios.width() == 0); 16770 } 16771 ios.width(25); 16772 internal(ios); 16773 { 16774 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16775 std::string ex(str, iter.base()); 16776 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16777 assert(ios.width() == 0); 16778 } 16779 } 16780 ios.imbue(lg); 16781 { 16782 ios.width(0); 16783 { 16784 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16785 std::string ex(str, iter.base()); 16786 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16787 assert(ios.width() == 0); 16788 } 16789 ios.width(25); 16790 left(ios); 16791 { 16792 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16793 std::string ex(str, iter.base()); 16794 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16795 assert(ios.width() == 0); 16796 } 16797 ios.width(25); 16798 right(ios); 16799 { 16800 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16801 std::string ex(str, iter.base()); 16802 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16803 assert(ios.width() == 0); 16804 } 16805 ios.width(25); 16806 internal(ios); 16807 { 16808 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16809 std::string ex(str, iter.base()); 16810 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16811 assert(ios.width() == 0); 16812 } 16813 } 16814 } 16815 } 16816 showpos(ios); 16817 { 16818 noshowpoint(ios); 16819 { 16820 ios.imbue(lc); 16821 { 16822 ios.width(0); 16823 { 16824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16825 std::string ex(str, iter.base()); 16826 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16827 assert(ios.width() == 0); 16828 } 16829 ios.width(25); 16830 left(ios); 16831 { 16832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16833 std::string ex(str, iter.base()); 16834 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16835 assert(ios.width() == 0); 16836 } 16837 ios.width(25); 16838 right(ios); 16839 { 16840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16841 std::string ex(str, iter.base()); 16842 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16843 assert(ios.width() == 0); 16844 } 16845 ios.width(25); 16846 internal(ios); 16847 { 16848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16849 std::string ex(str, iter.base()); 16850 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16851 assert(ios.width() == 0); 16852 } 16853 } 16854 ios.imbue(lg); 16855 { 16856 ios.width(0); 16857 { 16858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16859 std::string ex(str, iter.base()); 16860 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16861 assert(ios.width() == 0); 16862 } 16863 ios.width(25); 16864 left(ios); 16865 { 16866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16867 std::string ex(str, iter.base()); 16868 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16869 assert(ios.width() == 0); 16870 } 16871 ios.width(25); 16872 right(ios); 16873 { 16874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16875 std::string ex(str, iter.base()); 16876 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16877 assert(ios.width() == 0); 16878 } 16879 ios.width(25); 16880 internal(ios); 16881 { 16882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16883 std::string ex(str, iter.base()); 16884 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16885 assert(ios.width() == 0); 16886 } 16887 } 16888 } 16889 showpoint(ios); 16890 { 16891 ios.imbue(lc); 16892 { 16893 ios.width(0); 16894 { 16895 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16896 std::string ex(str, iter.base()); 16897 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16898 assert(ios.width() == 0); 16899 } 16900 ios.width(25); 16901 left(ios); 16902 { 16903 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16904 std::string ex(str, iter.base()); 16905 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16906 assert(ios.width() == 0); 16907 } 16908 ios.width(25); 16909 right(ios); 16910 { 16911 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16912 std::string ex(str, iter.base()); 16913 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16914 assert(ios.width() == 0); 16915 } 16916 ios.width(25); 16917 internal(ios); 16918 { 16919 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16920 std::string ex(str, iter.base()); 16921 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16922 assert(ios.width() == 0); 16923 } 16924 } 16925 ios.imbue(lg); 16926 { 16927 ios.width(0); 16928 { 16929 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16930 std::string ex(str, iter.base()); 16931 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16932 assert(ios.width() == 0); 16933 } 16934 ios.width(25); 16935 left(ios); 16936 { 16937 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16938 std::string ex(str, iter.base()); 16939 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16940 assert(ios.width() == 0); 16941 } 16942 ios.width(25); 16943 right(ios); 16944 { 16945 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16946 std::string ex(str, iter.base()); 16947 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16948 assert(ios.width() == 0); 16949 } 16950 ios.width(25); 16951 internal(ios); 16952 { 16953 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16954 std::string ex(str, iter.base()); 16955 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 16956 assert(ios.width() == 0); 16957 } 16958 } 16959 } 16960 } 16961 } 16962 uppercase(ios); 16963 { 16964 noshowpos(ios); 16965 { 16966 noshowpoint(ios); 16967 { 16968 ios.imbue(lc); 16969 { 16970 ios.width(0); 16971 { 16972 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16973 std::string ex(str, iter.base()); 16974 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16975 assert(ios.width() == 0); 16976 } 16977 ios.width(25); 16978 left(ios); 16979 { 16980 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16981 std::string ex(str, iter.base()); 16982 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16983 assert(ios.width() == 0); 16984 } 16985 ios.width(25); 16986 right(ios); 16987 { 16988 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16989 std::string ex(str, iter.base()); 16990 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16991 assert(ios.width() == 0); 16992 } 16993 ios.width(25); 16994 internal(ios); 16995 { 16996 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16997 std::string ex(str, iter.base()); 16998 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 16999 assert(ios.width() == 0); 17000 } 17001 } 17002 ios.imbue(lg); 17003 { 17004 ios.width(0); 17005 { 17006 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17007 std::string ex(str, iter.base()); 17008 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17009 assert(ios.width() == 0); 17010 } 17011 ios.width(25); 17012 left(ios); 17013 { 17014 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17015 std::string ex(str, iter.base()); 17016 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17017 assert(ios.width() == 0); 17018 } 17019 ios.width(25); 17020 right(ios); 17021 { 17022 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17023 std::string ex(str, iter.base()); 17024 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17025 assert(ios.width() == 0); 17026 } 17027 ios.width(25); 17028 internal(ios); 17029 { 17030 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17031 std::string ex(str, iter.base()); 17032 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17033 assert(ios.width() == 0); 17034 } 17035 } 17036 } 17037 showpoint(ios); 17038 { 17039 ios.imbue(lc); 17040 { 17041 ios.width(0); 17042 { 17043 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17044 std::string ex(str, iter.base()); 17045 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17046 assert(ios.width() == 0); 17047 } 17048 ios.width(25); 17049 left(ios); 17050 { 17051 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17052 std::string ex(str, iter.base()); 17053 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17054 assert(ios.width() == 0); 17055 } 17056 ios.width(25); 17057 right(ios); 17058 { 17059 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17060 std::string ex(str, iter.base()); 17061 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17062 assert(ios.width() == 0); 17063 } 17064 ios.width(25); 17065 internal(ios); 17066 { 17067 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17068 std::string ex(str, iter.base()); 17069 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17070 assert(ios.width() == 0); 17071 } 17072 } 17073 ios.imbue(lg); 17074 { 17075 ios.width(0); 17076 { 17077 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17078 std::string ex(str, iter.base()); 17079 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17080 assert(ios.width() == 0); 17081 } 17082 ios.width(25); 17083 left(ios); 17084 { 17085 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17086 std::string ex(str, iter.base()); 17087 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17088 assert(ios.width() == 0); 17089 } 17090 ios.width(25); 17091 right(ios); 17092 { 17093 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17094 std::string ex(str, iter.base()); 17095 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17096 assert(ios.width() == 0); 17097 } 17098 ios.width(25); 17099 internal(ios); 17100 { 17101 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17102 std::string ex(str, iter.base()); 17103 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17104 assert(ios.width() == 0); 17105 } 17106 } 17107 } 17108 } 17109 showpos(ios); 17110 { 17111 noshowpoint(ios); 17112 { 17113 ios.imbue(lc); 17114 { 17115 ios.width(0); 17116 { 17117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17118 std::string ex(str, iter.base()); 17119 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17120 assert(ios.width() == 0); 17121 } 17122 ios.width(25); 17123 left(ios); 17124 { 17125 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17126 std::string ex(str, iter.base()); 17127 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17128 assert(ios.width() == 0); 17129 } 17130 ios.width(25); 17131 right(ios); 17132 { 17133 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17134 std::string ex(str, iter.base()); 17135 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17136 assert(ios.width() == 0); 17137 } 17138 ios.width(25); 17139 internal(ios); 17140 { 17141 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17142 std::string ex(str, iter.base()); 17143 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17144 assert(ios.width() == 0); 17145 } 17146 } 17147 ios.imbue(lg); 17148 { 17149 ios.width(0); 17150 { 17151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17152 std::string ex(str, iter.base()); 17153 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17154 assert(ios.width() == 0); 17155 } 17156 ios.width(25); 17157 left(ios); 17158 { 17159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17160 std::string ex(str, iter.base()); 17161 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17162 assert(ios.width() == 0); 17163 } 17164 ios.width(25); 17165 right(ios); 17166 { 17167 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17168 std::string ex(str, iter.base()); 17169 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17170 assert(ios.width() == 0); 17171 } 17172 ios.width(25); 17173 internal(ios); 17174 { 17175 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17176 std::string ex(str, iter.base()); 17177 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17178 assert(ios.width() == 0); 17179 } 17180 } 17181 } 17182 showpoint(ios); 17183 { 17184 ios.imbue(lc); 17185 { 17186 ios.width(0); 17187 { 17188 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17189 std::string ex(str, iter.base()); 17190 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17191 assert(ios.width() == 0); 17192 } 17193 ios.width(25); 17194 left(ios); 17195 { 17196 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17197 std::string ex(str, iter.base()); 17198 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17199 assert(ios.width() == 0); 17200 } 17201 ios.width(25); 17202 right(ios); 17203 { 17204 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17205 std::string ex(str, iter.base()); 17206 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17207 assert(ios.width() == 0); 17208 } 17209 ios.width(25); 17210 internal(ios); 17211 { 17212 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17213 std::string ex(str, iter.base()); 17214 assert(ex == "-0.000000000000000000000000000000000000000000000000000000000000"); 17215 assert(ios.width() == 0); 17216 } 17217 } 17218 ios.imbue(lg); 17219 { 17220 ios.width(0); 17221 { 17222 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17223 std::string ex(str, iter.base()); 17224 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17225 assert(ios.width() == 0); 17226 } 17227 ios.width(25); 17228 left(ios); 17229 { 17230 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17231 std::string ex(str, iter.base()); 17232 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17233 assert(ios.width() == 0); 17234 } 17235 ios.width(25); 17236 right(ios); 17237 { 17238 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17239 std::string ex(str, iter.base()); 17240 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17241 assert(ios.width() == 0); 17242 } 17243 ios.width(25); 17244 internal(ios); 17245 { 17246 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17247 std::string ex(str, iter.base()); 17248 assert(ex == "-0;000000000000000000000000000000000000000000000000000000000000"); 17249 assert(ios.width() == 0); 17250 } 17251 } 17252 } 17253 } 17254 } 17255 } 17256 } 17257 } 17258 } 17259 17260 void test8() 17261 { 17262 char str[200]; 17263 output_iterator<char*> iter; 17264 std::locale lc = std::locale::classic(); 17265 std::locale lg(lc, new my_numpunct); 17266 const my_facet f(1); 17267 { 17268 long double v = 1234567890.125; 17269 std::ios ios(0); 17270 fixed(ios); 17271 // %f 17272 { 17273 ios.precision(0); 17274 { 17275 nouppercase(ios); 17276 { 17277 noshowpos(ios); 17278 { 17279 noshowpoint(ios); 17280 { 17281 ios.imbue(lc); 17282 { 17283 ios.width(0); 17284 { 17285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17286 std::string ex(str, iter.base()); 17287 assert(ex == "1234567890"); 17288 assert(ios.width() == 0); 17289 } 17290 ios.width(25); 17291 left(ios); 17292 { 17293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17294 std::string ex(str, iter.base()); 17295 assert(ex == "1234567890***************"); 17296 assert(ios.width() == 0); 17297 } 17298 ios.width(25); 17299 right(ios); 17300 { 17301 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17302 std::string ex(str, iter.base()); 17303 assert(ex == "***************1234567890"); 17304 assert(ios.width() == 0); 17305 } 17306 ios.width(25); 17307 internal(ios); 17308 { 17309 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17310 std::string ex(str, iter.base()); 17311 assert(ex == "***************1234567890"); 17312 assert(ios.width() == 0); 17313 } 17314 } 17315 ios.imbue(lg); 17316 { 17317 ios.width(0); 17318 { 17319 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17320 std::string ex(str, iter.base()); 17321 assert(ex == "1_234_567_89_0"); 17322 assert(ios.width() == 0); 17323 } 17324 ios.width(25); 17325 left(ios); 17326 { 17327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17328 std::string ex(str, iter.base()); 17329 assert(ex == "1_234_567_89_0***********"); 17330 assert(ios.width() == 0); 17331 } 17332 ios.width(25); 17333 right(ios); 17334 { 17335 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17336 std::string ex(str, iter.base()); 17337 assert(ex == "***********1_234_567_89_0"); 17338 assert(ios.width() == 0); 17339 } 17340 ios.width(25); 17341 internal(ios); 17342 { 17343 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17344 std::string ex(str, iter.base()); 17345 assert(ex == "***********1_234_567_89_0"); 17346 assert(ios.width() == 0); 17347 } 17348 } 17349 } 17350 showpoint(ios); 17351 { 17352 ios.imbue(lc); 17353 { 17354 ios.width(0); 17355 { 17356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17357 std::string ex(str, iter.base()); 17358 assert(ex == "1234567890."); 17359 assert(ios.width() == 0); 17360 } 17361 ios.width(25); 17362 left(ios); 17363 { 17364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17365 std::string ex(str, iter.base()); 17366 assert(ex == "1234567890.**************"); 17367 assert(ios.width() == 0); 17368 } 17369 ios.width(25); 17370 right(ios); 17371 { 17372 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17373 std::string ex(str, iter.base()); 17374 assert(ex == "**************1234567890."); 17375 assert(ios.width() == 0); 17376 } 17377 ios.width(25); 17378 internal(ios); 17379 { 17380 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17381 std::string ex(str, iter.base()); 17382 assert(ex == "**************1234567890."); 17383 assert(ios.width() == 0); 17384 } 17385 } 17386 ios.imbue(lg); 17387 { 17388 ios.width(0); 17389 { 17390 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17391 std::string ex(str, iter.base()); 17392 assert(ex == "1_234_567_89_0;"); 17393 assert(ios.width() == 0); 17394 } 17395 ios.width(25); 17396 left(ios); 17397 { 17398 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17399 std::string ex(str, iter.base()); 17400 assert(ex == "1_234_567_89_0;**********"); 17401 assert(ios.width() == 0); 17402 } 17403 ios.width(25); 17404 right(ios); 17405 { 17406 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17407 std::string ex(str, iter.base()); 17408 assert(ex == "**********1_234_567_89_0;"); 17409 assert(ios.width() == 0); 17410 } 17411 ios.width(25); 17412 internal(ios); 17413 { 17414 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17415 std::string ex(str, iter.base()); 17416 assert(ex == "**********1_234_567_89_0;"); 17417 assert(ios.width() == 0); 17418 } 17419 } 17420 } 17421 } 17422 showpos(ios); 17423 { 17424 noshowpoint(ios); 17425 { 17426 ios.imbue(lc); 17427 { 17428 ios.width(0); 17429 { 17430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17431 std::string ex(str, iter.base()); 17432 assert(ex == "+1234567890"); 17433 assert(ios.width() == 0); 17434 } 17435 ios.width(25); 17436 left(ios); 17437 { 17438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17439 std::string ex(str, iter.base()); 17440 assert(ex == "+1234567890**************"); 17441 assert(ios.width() == 0); 17442 } 17443 ios.width(25); 17444 right(ios); 17445 { 17446 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17447 std::string ex(str, iter.base()); 17448 assert(ex == "**************+1234567890"); 17449 assert(ios.width() == 0); 17450 } 17451 ios.width(25); 17452 internal(ios); 17453 { 17454 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17455 std::string ex(str, iter.base()); 17456 assert(ex == "+**************1234567890"); 17457 assert(ios.width() == 0); 17458 } 17459 } 17460 ios.imbue(lg); 17461 { 17462 ios.width(0); 17463 { 17464 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17465 std::string ex(str, iter.base()); 17466 assert(ex == "+1_234_567_89_0"); 17467 assert(ios.width() == 0); 17468 } 17469 ios.width(25); 17470 left(ios); 17471 { 17472 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17473 std::string ex(str, iter.base()); 17474 assert(ex == "+1_234_567_89_0**********"); 17475 assert(ios.width() == 0); 17476 } 17477 ios.width(25); 17478 right(ios); 17479 { 17480 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17481 std::string ex(str, iter.base()); 17482 assert(ex == "**********+1_234_567_89_0"); 17483 assert(ios.width() == 0); 17484 } 17485 ios.width(25); 17486 internal(ios); 17487 { 17488 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17489 std::string ex(str, iter.base()); 17490 assert(ex == "+**********1_234_567_89_0"); 17491 assert(ios.width() == 0); 17492 } 17493 } 17494 } 17495 showpoint(ios); 17496 { 17497 ios.imbue(lc); 17498 { 17499 ios.width(0); 17500 { 17501 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17502 std::string ex(str, iter.base()); 17503 assert(ex == "+1234567890."); 17504 assert(ios.width() == 0); 17505 } 17506 ios.width(25); 17507 left(ios); 17508 { 17509 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17510 std::string ex(str, iter.base()); 17511 assert(ex == "+1234567890.*************"); 17512 assert(ios.width() == 0); 17513 } 17514 ios.width(25); 17515 right(ios); 17516 { 17517 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17518 std::string ex(str, iter.base()); 17519 assert(ex == "*************+1234567890."); 17520 assert(ios.width() == 0); 17521 } 17522 ios.width(25); 17523 internal(ios); 17524 { 17525 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17526 std::string ex(str, iter.base()); 17527 assert(ex == "+*************1234567890."); 17528 assert(ios.width() == 0); 17529 } 17530 } 17531 ios.imbue(lg); 17532 { 17533 ios.width(0); 17534 { 17535 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17536 std::string ex(str, iter.base()); 17537 assert(ex == "+1_234_567_89_0;"); 17538 assert(ios.width() == 0); 17539 } 17540 ios.width(25); 17541 left(ios); 17542 { 17543 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17544 std::string ex(str, iter.base()); 17545 assert(ex == "+1_234_567_89_0;*********"); 17546 assert(ios.width() == 0); 17547 } 17548 ios.width(25); 17549 right(ios); 17550 { 17551 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17552 std::string ex(str, iter.base()); 17553 assert(ex == "*********+1_234_567_89_0;"); 17554 assert(ios.width() == 0); 17555 } 17556 ios.width(25); 17557 internal(ios); 17558 { 17559 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17560 std::string ex(str, iter.base()); 17561 assert(ex == "+*********1_234_567_89_0;"); 17562 assert(ios.width() == 0); 17563 } 17564 } 17565 } 17566 } 17567 } 17568 uppercase(ios); 17569 { 17570 noshowpos(ios); 17571 { 17572 noshowpoint(ios); 17573 { 17574 ios.imbue(lc); 17575 { 17576 ios.width(0); 17577 { 17578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17579 std::string ex(str, iter.base()); 17580 assert(ex == "1234567890"); 17581 assert(ios.width() == 0); 17582 } 17583 ios.width(25); 17584 left(ios); 17585 { 17586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17587 std::string ex(str, iter.base()); 17588 assert(ex == "1234567890***************"); 17589 assert(ios.width() == 0); 17590 } 17591 ios.width(25); 17592 right(ios); 17593 { 17594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17595 std::string ex(str, iter.base()); 17596 assert(ex == "***************1234567890"); 17597 assert(ios.width() == 0); 17598 } 17599 ios.width(25); 17600 internal(ios); 17601 { 17602 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17603 std::string ex(str, iter.base()); 17604 assert(ex == "***************1234567890"); 17605 assert(ios.width() == 0); 17606 } 17607 } 17608 ios.imbue(lg); 17609 { 17610 ios.width(0); 17611 { 17612 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17613 std::string ex(str, iter.base()); 17614 assert(ex == "1_234_567_89_0"); 17615 assert(ios.width() == 0); 17616 } 17617 ios.width(25); 17618 left(ios); 17619 { 17620 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17621 std::string ex(str, iter.base()); 17622 assert(ex == "1_234_567_89_0***********"); 17623 assert(ios.width() == 0); 17624 } 17625 ios.width(25); 17626 right(ios); 17627 { 17628 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17629 std::string ex(str, iter.base()); 17630 assert(ex == "***********1_234_567_89_0"); 17631 assert(ios.width() == 0); 17632 } 17633 ios.width(25); 17634 internal(ios); 17635 { 17636 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17637 std::string ex(str, iter.base()); 17638 assert(ex == "***********1_234_567_89_0"); 17639 assert(ios.width() == 0); 17640 } 17641 } 17642 } 17643 showpoint(ios); 17644 { 17645 ios.imbue(lc); 17646 { 17647 ios.width(0); 17648 { 17649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17650 std::string ex(str, iter.base()); 17651 assert(ex == "1234567890."); 17652 assert(ios.width() == 0); 17653 } 17654 ios.width(25); 17655 left(ios); 17656 { 17657 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17658 std::string ex(str, iter.base()); 17659 assert(ex == "1234567890.**************"); 17660 assert(ios.width() == 0); 17661 } 17662 ios.width(25); 17663 right(ios); 17664 { 17665 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17666 std::string ex(str, iter.base()); 17667 assert(ex == "**************1234567890."); 17668 assert(ios.width() == 0); 17669 } 17670 ios.width(25); 17671 internal(ios); 17672 { 17673 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17674 std::string ex(str, iter.base()); 17675 assert(ex == "**************1234567890."); 17676 assert(ios.width() == 0); 17677 } 17678 } 17679 ios.imbue(lg); 17680 { 17681 ios.width(0); 17682 { 17683 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17684 std::string ex(str, iter.base()); 17685 assert(ex == "1_234_567_89_0;"); 17686 assert(ios.width() == 0); 17687 } 17688 ios.width(25); 17689 left(ios); 17690 { 17691 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17692 std::string ex(str, iter.base()); 17693 assert(ex == "1_234_567_89_0;**********"); 17694 assert(ios.width() == 0); 17695 } 17696 ios.width(25); 17697 right(ios); 17698 { 17699 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17700 std::string ex(str, iter.base()); 17701 assert(ex == "**********1_234_567_89_0;"); 17702 assert(ios.width() == 0); 17703 } 17704 ios.width(25); 17705 internal(ios); 17706 { 17707 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17708 std::string ex(str, iter.base()); 17709 assert(ex == "**********1_234_567_89_0;"); 17710 assert(ios.width() == 0); 17711 } 17712 } 17713 } 17714 } 17715 showpos(ios); 17716 { 17717 noshowpoint(ios); 17718 { 17719 ios.imbue(lc); 17720 { 17721 ios.width(0); 17722 { 17723 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17724 std::string ex(str, iter.base()); 17725 assert(ex == "+1234567890"); 17726 assert(ios.width() == 0); 17727 } 17728 ios.width(25); 17729 left(ios); 17730 { 17731 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17732 std::string ex(str, iter.base()); 17733 assert(ex == "+1234567890**************"); 17734 assert(ios.width() == 0); 17735 } 17736 ios.width(25); 17737 right(ios); 17738 { 17739 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17740 std::string ex(str, iter.base()); 17741 assert(ex == "**************+1234567890"); 17742 assert(ios.width() == 0); 17743 } 17744 ios.width(25); 17745 internal(ios); 17746 { 17747 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17748 std::string ex(str, iter.base()); 17749 assert(ex == "+**************1234567890"); 17750 assert(ios.width() == 0); 17751 } 17752 } 17753 ios.imbue(lg); 17754 { 17755 ios.width(0); 17756 { 17757 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17758 std::string ex(str, iter.base()); 17759 assert(ex == "+1_234_567_89_0"); 17760 assert(ios.width() == 0); 17761 } 17762 ios.width(25); 17763 left(ios); 17764 { 17765 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17766 std::string ex(str, iter.base()); 17767 assert(ex == "+1_234_567_89_0**********"); 17768 assert(ios.width() == 0); 17769 } 17770 ios.width(25); 17771 right(ios); 17772 { 17773 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17774 std::string ex(str, iter.base()); 17775 assert(ex == "**********+1_234_567_89_0"); 17776 assert(ios.width() == 0); 17777 } 17778 ios.width(25); 17779 internal(ios); 17780 { 17781 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17782 std::string ex(str, iter.base()); 17783 assert(ex == "+**********1_234_567_89_0"); 17784 assert(ios.width() == 0); 17785 } 17786 } 17787 } 17788 showpoint(ios); 17789 { 17790 ios.imbue(lc); 17791 { 17792 ios.width(0); 17793 { 17794 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17795 std::string ex(str, iter.base()); 17796 assert(ex == "+1234567890."); 17797 assert(ios.width() == 0); 17798 } 17799 ios.width(25); 17800 left(ios); 17801 { 17802 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17803 std::string ex(str, iter.base()); 17804 assert(ex == "+1234567890.*************"); 17805 assert(ios.width() == 0); 17806 } 17807 ios.width(25); 17808 right(ios); 17809 { 17810 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17811 std::string ex(str, iter.base()); 17812 assert(ex == "*************+1234567890."); 17813 assert(ios.width() == 0); 17814 } 17815 ios.width(25); 17816 internal(ios); 17817 { 17818 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17819 std::string ex(str, iter.base()); 17820 assert(ex == "+*************1234567890."); 17821 assert(ios.width() == 0); 17822 } 17823 } 17824 ios.imbue(lg); 17825 { 17826 ios.width(0); 17827 { 17828 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17829 std::string ex(str, iter.base()); 17830 assert(ex == "+1_234_567_89_0;"); 17831 assert(ios.width() == 0); 17832 } 17833 ios.width(25); 17834 left(ios); 17835 { 17836 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17837 std::string ex(str, iter.base()); 17838 assert(ex == "+1_234_567_89_0;*********"); 17839 assert(ios.width() == 0); 17840 } 17841 ios.width(25); 17842 right(ios); 17843 { 17844 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17845 std::string ex(str, iter.base()); 17846 assert(ex == "*********+1_234_567_89_0;"); 17847 assert(ios.width() == 0); 17848 } 17849 ios.width(25); 17850 internal(ios); 17851 { 17852 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17853 std::string ex(str, iter.base()); 17854 assert(ex == "+*********1_234_567_89_0;"); 17855 assert(ios.width() == 0); 17856 } 17857 } 17858 } 17859 } 17860 } 17861 } 17862 ios.precision(1); 17863 { 17864 nouppercase(ios); 17865 { 17866 noshowpos(ios); 17867 { 17868 noshowpoint(ios); 17869 { 17870 ios.imbue(lc); 17871 { 17872 ios.width(0); 17873 { 17874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17875 std::string ex(str, iter.base()); 17876 assert(ex == "1234567890.1"); 17877 assert(ios.width() == 0); 17878 } 17879 ios.width(25); 17880 left(ios); 17881 { 17882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17883 std::string ex(str, iter.base()); 17884 assert(ex == "1234567890.1*************"); 17885 assert(ios.width() == 0); 17886 } 17887 ios.width(25); 17888 right(ios); 17889 { 17890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17891 std::string ex(str, iter.base()); 17892 assert(ex == "*************1234567890.1"); 17893 assert(ios.width() == 0); 17894 } 17895 ios.width(25); 17896 internal(ios); 17897 { 17898 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17899 std::string ex(str, iter.base()); 17900 assert(ex == "*************1234567890.1"); 17901 assert(ios.width() == 0); 17902 } 17903 } 17904 ios.imbue(lg); 17905 { 17906 ios.width(0); 17907 { 17908 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17909 std::string ex(str, iter.base()); 17910 assert(ex == "1_234_567_89_0;1"); 17911 assert(ios.width() == 0); 17912 } 17913 ios.width(25); 17914 left(ios); 17915 { 17916 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17917 std::string ex(str, iter.base()); 17918 assert(ex == "1_234_567_89_0;1*********"); 17919 assert(ios.width() == 0); 17920 } 17921 ios.width(25); 17922 right(ios); 17923 { 17924 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17925 std::string ex(str, iter.base()); 17926 assert(ex == "*********1_234_567_89_0;1"); 17927 assert(ios.width() == 0); 17928 } 17929 ios.width(25); 17930 internal(ios); 17931 { 17932 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17933 std::string ex(str, iter.base()); 17934 assert(ex == "*********1_234_567_89_0;1"); 17935 assert(ios.width() == 0); 17936 } 17937 } 17938 } 17939 showpoint(ios); 17940 { 17941 ios.imbue(lc); 17942 { 17943 ios.width(0); 17944 { 17945 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17946 std::string ex(str, iter.base()); 17947 assert(ex == "1234567890.1"); 17948 assert(ios.width() == 0); 17949 } 17950 ios.width(25); 17951 left(ios); 17952 { 17953 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17954 std::string ex(str, iter.base()); 17955 assert(ex == "1234567890.1*************"); 17956 assert(ios.width() == 0); 17957 } 17958 ios.width(25); 17959 right(ios); 17960 { 17961 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17962 std::string ex(str, iter.base()); 17963 assert(ex == "*************1234567890.1"); 17964 assert(ios.width() == 0); 17965 } 17966 ios.width(25); 17967 internal(ios); 17968 { 17969 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17970 std::string ex(str, iter.base()); 17971 assert(ex == "*************1234567890.1"); 17972 assert(ios.width() == 0); 17973 } 17974 } 17975 ios.imbue(lg); 17976 { 17977 ios.width(0); 17978 { 17979 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17980 std::string ex(str, iter.base()); 17981 assert(ex == "1_234_567_89_0;1"); 17982 assert(ios.width() == 0); 17983 } 17984 ios.width(25); 17985 left(ios); 17986 { 17987 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17988 std::string ex(str, iter.base()); 17989 assert(ex == "1_234_567_89_0;1*********"); 17990 assert(ios.width() == 0); 17991 } 17992 ios.width(25); 17993 right(ios); 17994 { 17995 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17996 std::string ex(str, iter.base()); 17997 assert(ex == "*********1_234_567_89_0;1"); 17998 assert(ios.width() == 0); 17999 } 18000 ios.width(25); 18001 internal(ios); 18002 { 18003 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18004 std::string ex(str, iter.base()); 18005 assert(ex == "*********1_234_567_89_0;1"); 18006 assert(ios.width() == 0); 18007 } 18008 } 18009 } 18010 } 18011 showpos(ios); 18012 { 18013 noshowpoint(ios); 18014 { 18015 ios.imbue(lc); 18016 { 18017 ios.width(0); 18018 { 18019 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18020 std::string ex(str, iter.base()); 18021 assert(ex == "+1234567890.1"); 18022 assert(ios.width() == 0); 18023 } 18024 ios.width(25); 18025 left(ios); 18026 { 18027 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18028 std::string ex(str, iter.base()); 18029 assert(ex == "+1234567890.1************"); 18030 assert(ios.width() == 0); 18031 } 18032 ios.width(25); 18033 right(ios); 18034 { 18035 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18036 std::string ex(str, iter.base()); 18037 assert(ex == "************+1234567890.1"); 18038 assert(ios.width() == 0); 18039 } 18040 ios.width(25); 18041 internal(ios); 18042 { 18043 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18044 std::string ex(str, iter.base()); 18045 assert(ex == "+************1234567890.1"); 18046 assert(ios.width() == 0); 18047 } 18048 } 18049 ios.imbue(lg); 18050 { 18051 ios.width(0); 18052 { 18053 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18054 std::string ex(str, iter.base()); 18055 assert(ex == "+1_234_567_89_0;1"); 18056 assert(ios.width() == 0); 18057 } 18058 ios.width(25); 18059 left(ios); 18060 { 18061 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18062 std::string ex(str, iter.base()); 18063 assert(ex == "+1_234_567_89_0;1********"); 18064 assert(ios.width() == 0); 18065 } 18066 ios.width(25); 18067 right(ios); 18068 { 18069 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18070 std::string ex(str, iter.base()); 18071 assert(ex == "********+1_234_567_89_0;1"); 18072 assert(ios.width() == 0); 18073 } 18074 ios.width(25); 18075 internal(ios); 18076 { 18077 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18078 std::string ex(str, iter.base()); 18079 assert(ex == "+********1_234_567_89_0;1"); 18080 assert(ios.width() == 0); 18081 } 18082 } 18083 } 18084 showpoint(ios); 18085 { 18086 ios.imbue(lc); 18087 { 18088 ios.width(0); 18089 { 18090 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18091 std::string ex(str, iter.base()); 18092 assert(ex == "+1234567890.1"); 18093 assert(ios.width() == 0); 18094 } 18095 ios.width(25); 18096 left(ios); 18097 { 18098 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18099 std::string ex(str, iter.base()); 18100 assert(ex == "+1234567890.1************"); 18101 assert(ios.width() == 0); 18102 } 18103 ios.width(25); 18104 right(ios); 18105 { 18106 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18107 std::string ex(str, iter.base()); 18108 assert(ex == "************+1234567890.1"); 18109 assert(ios.width() == 0); 18110 } 18111 ios.width(25); 18112 internal(ios); 18113 { 18114 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18115 std::string ex(str, iter.base()); 18116 assert(ex == "+************1234567890.1"); 18117 assert(ios.width() == 0); 18118 } 18119 } 18120 ios.imbue(lg); 18121 { 18122 ios.width(0); 18123 { 18124 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18125 std::string ex(str, iter.base()); 18126 assert(ex == "+1_234_567_89_0;1"); 18127 assert(ios.width() == 0); 18128 } 18129 ios.width(25); 18130 left(ios); 18131 { 18132 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18133 std::string ex(str, iter.base()); 18134 assert(ex == "+1_234_567_89_0;1********"); 18135 assert(ios.width() == 0); 18136 } 18137 ios.width(25); 18138 right(ios); 18139 { 18140 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18141 std::string ex(str, iter.base()); 18142 assert(ex == "********+1_234_567_89_0;1"); 18143 assert(ios.width() == 0); 18144 } 18145 ios.width(25); 18146 internal(ios); 18147 { 18148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18149 std::string ex(str, iter.base()); 18150 assert(ex == "+********1_234_567_89_0;1"); 18151 assert(ios.width() == 0); 18152 } 18153 } 18154 } 18155 } 18156 } 18157 uppercase(ios); 18158 { 18159 noshowpos(ios); 18160 { 18161 noshowpoint(ios); 18162 { 18163 ios.imbue(lc); 18164 { 18165 ios.width(0); 18166 { 18167 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18168 std::string ex(str, iter.base()); 18169 assert(ex == "1234567890.1"); 18170 assert(ios.width() == 0); 18171 } 18172 ios.width(25); 18173 left(ios); 18174 { 18175 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18176 std::string ex(str, iter.base()); 18177 assert(ex == "1234567890.1*************"); 18178 assert(ios.width() == 0); 18179 } 18180 ios.width(25); 18181 right(ios); 18182 { 18183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18184 std::string ex(str, iter.base()); 18185 assert(ex == "*************1234567890.1"); 18186 assert(ios.width() == 0); 18187 } 18188 ios.width(25); 18189 internal(ios); 18190 { 18191 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18192 std::string ex(str, iter.base()); 18193 assert(ex == "*************1234567890.1"); 18194 assert(ios.width() == 0); 18195 } 18196 } 18197 ios.imbue(lg); 18198 { 18199 ios.width(0); 18200 { 18201 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18202 std::string ex(str, iter.base()); 18203 assert(ex == "1_234_567_89_0;1"); 18204 assert(ios.width() == 0); 18205 } 18206 ios.width(25); 18207 left(ios); 18208 { 18209 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18210 std::string ex(str, iter.base()); 18211 assert(ex == "1_234_567_89_0;1*********"); 18212 assert(ios.width() == 0); 18213 } 18214 ios.width(25); 18215 right(ios); 18216 { 18217 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18218 std::string ex(str, iter.base()); 18219 assert(ex == "*********1_234_567_89_0;1"); 18220 assert(ios.width() == 0); 18221 } 18222 ios.width(25); 18223 internal(ios); 18224 { 18225 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18226 std::string ex(str, iter.base()); 18227 assert(ex == "*********1_234_567_89_0;1"); 18228 assert(ios.width() == 0); 18229 } 18230 } 18231 } 18232 showpoint(ios); 18233 { 18234 ios.imbue(lc); 18235 { 18236 ios.width(0); 18237 { 18238 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18239 std::string ex(str, iter.base()); 18240 assert(ex == "1234567890.1"); 18241 assert(ios.width() == 0); 18242 } 18243 ios.width(25); 18244 left(ios); 18245 { 18246 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18247 std::string ex(str, iter.base()); 18248 assert(ex == "1234567890.1*************"); 18249 assert(ios.width() == 0); 18250 } 18251 ios.width(25); 18252 right(ios); 18253 { 18254 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18255 std::string ex(str, iter.base()); 18256 assert(ex == "*************1234567890.1"); 18257 assert(ios.width() == 0); 18258 } 18259 ios.width(25); 18260 internal(ios); 18261 { 18262 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18263 std::string ex(str, iter.base()); 18264 assert(ex == "*************1234567890.1"); 18265 assert(ios.width() == 0); 18266 } 18267 } 18268 ios.imbue(lg); 18269 { 18270 ios.width(0); 18271 { 18272 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18273 std::string ex(str, iter.base()); 18274 assert(ex == "1_234_567_89_0;1"); 18275 assert(ios.width() == 0); 18276 } 18277 ios.width(25); 18278 left(ios); 18279 { 18280 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18281 std::string ex(str, iter.base()); 18282 assert(ex == "1_234_567_89_0;1*********"); 18283 assert(ios.width() == 0); 18284 } 18285 ios.width(25); 18286 right(ios); 18287 { 18288 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18289 std::string ex(str, iter.base()); 18290 assert(ex == "*********1_234_567_89_0;1"); 18291 assert(ios.width() == 0); 18292 } 18293 ios.width(25); 18294 internal(ios); 18295 { 18296 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18297 std::string ex(str, iter.base()); 18298 assert(ex == "*********1_234_567_89_0;1"); 18299 assert(ios.width() == 0); 18300 } 18301 } 18302 } 18303 } 18304 showpos(ios); 18305 { 18306 noshowpoint(ios); 18307 { 18308 ios.imbue(lc); 18309 { 18310 ios.width(0); 18311 { 18312 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18313 std::string ex(str, iter.base()); 18314 assert(ex == "+1234567890.1"); 18315 assert(ios.width() == 0); 18316 } 18317 ios.width(25); 18318 left(ios); 18319 { 18320 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18321 std::string ex(str, iter.base()); 18322 assert(ex == "+1234567890.1************"); 18323 assert(ios.width() == 0); 18324 } 18325 ios.width(25); 18326 right(ios); 18327 { 18328 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18329 std::string ex(str, iter.base()); 18330 assert(ex == "************+1234567890.1"); 18331 assert(ios.width() == 0); 18332 } 18333 ios.width(25); 18334 internal(ios); 18335 { 18336 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18337 std::string ex(str, iter.base()); 18338 assert(ex == "+************1234567890.1"); 18339 assert(ios.width() == 0); 18340 } 18341 } 18342 ios.imbue(lg); 18343 { 18344 ios.width(0); 18345 { 18346 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18347 std::string ex(str, iter.base()); 18348 assert(ex == "+1_234_567_89_0;1"); 18349 assert(ios.width() == 0); 18350 } 18351 ios.width(25); 18352 left(ios); 18353 { 18354 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18355 std::string ex(str, iter.base()); 18356 assert(ex == "+1_234_567_89_0;1********"); 18357 assert(ios.width() == 0); 18358 } 18359 ios.width(25); 18360 right(ios); 18361 { 18362 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18363 std::string ex(str, iter.base()); 18364 assert(ex == "********+1_234_567_89_0;1"); 18365 assert(ios.width() == 0); 18366 } 18367 ios.width(25); 18368 internal(ios); 18369 { 18370 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18371 std::string ex(str, iter.base()); 18372 assert(ex == "+********1_234_567_89_0;1"); 18373 assert(ios.width() == 0); 18374 } 18375 } 18376 } 18377 showpoint(ios); 18378 { 18379 ios.imbue(lc); 18380 { 18381 ios.width(0); 18382 { 18383 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18384 std::string ex(str, iter.base()); 18385 assert(ex == "+1234567890.1"); 18386 assert(ios.width() == 0); 18387 } 18388 ios.width(25); 18389 left(ios); 18390 { 18391 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18392 std::string ex(str, iter.base()); 18393 assert(ex == "+1234567890.1************"); 18394 assert(ios.width() == 0); 18395 } 18396 ios.width(25); 18397 right(ios); 18398 { 18399 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18400 std::string ex(str, iter.base()); 18401 assert(ex == "************+1234567890.1"); 18402 assert(ios.width() == 0); 18403 } 18404 ios.width(25); 18405 internal(ios); 18406 { 18407 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18408 std::string ex(str, iter.base()); 18409 assert(ex == "+************1234567890.1"); 18410 assert(ios.width() == 0); 18411 } 18412 } 18413 ios.imbue(lg); 18414 { 18415 ios.width(0); 18416 { 18417 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18418 std::string ex(str, iter.base()); 18419 assert(ex == "+1_234_567_89_0;1"); 18420 assert(ios.width() == 0); 18421 } 18422 ios.width(25); 18423 left(ios); 18424 { 18425 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18426 std::string ex(str, iter.base()); 18427 assert(ex == "+1_234_567_89_0;1********"); 18428 assert(ios.width() == 0); 18429 } 18430 ios.width(25); 18431 right(ios); 18432 { 18433 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18434 std::string ex(str, iter.base()); 18435 assert(ex == "********+1_234_567_89_0;1"); 18436 assert(ios.width() == 0); 18437 } 18438 ios.width(25); 18439 internal(ios); 18440 { 18441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18442 std::string ex(str, iter.base()); 18443 assert(ex == "+********1_234_567_89_0;1"); 18444 assert(ios.width() == 0); 18445 } 18446 } 18447 } 18448 } 18449 } 18450 } 18451 ios.precision(6); 18452 { 18453 nouppercase(ios); 18454 { 18455 noshowpos(ios); 18456 { 18457 noshowpoint(ios); 18458 { 18459 ios.imbue(lc); 18460 { 18461 ios.width(0); 18462 { 18463 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18464 std::string ex(str, iter.base()); 18465 assert(ex == "1234567890.125000"); 18466 assert(ios.width() == 0); 18467 } 18468 ios.width(25); 18469 left(ios); 18470 { 18471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18472 std::string ex(str, iter.base()); 18473 assert(ex == "1234567890.125000********"); 18474 assert(ios.width() == 0); 18475 } 18476 ios.width(25); 18477 right(ios); 18478 { 18479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18480 std::string ex(str, iter.base()); 18481 assert(ex == "********1234567890.125000"); 18482 assert(ios.width() == 0); 18483 } 18484 ios.width(25); 18485 internal(ios); 18486 { 18487 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18488 std::string ex(str, iter.base()); 18489 assert(ex == "********1234567890.125000"); 18490 assert(ios.width() == 0); 18491 } 18492 } 18493 ios.imbue(lg); 18494 { 18495 ios.width(0); 18496 { 18497 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18498 std::string ex(str, iter.base()); 18499 assert(ex == "1_234_567_89_0;125000"); 18500 assert(ios.width() == 0); 18501 } 18502 ios.width(25); 18503 left(ios); 18504 { 18505 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18506 std::string ex(str, iter.base()); 18507 assert(ex == "1_234_567_89_0;125000****"); 18508 assert(ios.width() == 0); 18509 } 18510 ios.width(25); 18511 right(ios); 18512 { 18513 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18514 std::string ex(str, iter.base()); 18515 assert(ex == "****1_234_567_89_0;125000"); 18516 assert(ios.width() == 0); 18517 } 18518 ios.width(25); 18519 internal(ios); 18520 { 18521 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18522 std::string ex(str, iter.base()); 18523 assert(ex == "****1_234_567_89_0;125000"); 18524 assert(ios.width() == 0); 18525 } 18526 } 18527 } 18528 showpoint(ios); 18529 { 18530 ios.imbue(lc); 18531 { 18532 ios.width(0); 18533 { 18534 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18535 std::string ex(str, iter.base()); 18536 assert(ex == "1234567890.125000"); 18537 assert(ios.width() == 0); 18538 } 18539 ios.width(25); 18540 left(ios); 18541 { 18542 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18543 std::string ex(str, iter.base()); 18544 assert(ex == "1234567890.125000********"); 18545 assert(ios.width() == 0); 18546 } 18547 ios.width(25); 18548 right(ios); 18549 { 18550 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18551 std::string ex(str, iter.base()); 18552 assert(ex == "********1234567890.125000"); 18553 assert(ios.width() == 0); 18554 } 18555 ios.width(25); 18556 internal(ios); 18557 { 18558 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18559 std::string ex(str, iter.base()); 18560 assert(ex == "********1234567890.125000"); 18561 assert(ios.width() == 0); 18562 } 18563 } 18564 ios.imbue(lg); 18565 { 18566 ios.width(0); 18567 { 18568 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18569 std::string ex(str, iter.base()); 18570 assert(ex == "1_234_567_89_0;125000"); 18571 assert(ios.width() == 0); 18572 } 18573 ios.width(25); 18574 left(ios); 18575 { 18576 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18577 std::string ex(str, iter.base()); 18578 assert(ex == "1_234_567_89_0;125000****"); 18579 assert(ios.width() == 0); 18580 } 18581 ios.width(25); 18582 right(ios); 18583 { 18584 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18585 std::string ex(str, iter.base()); 18586 assert(ex == "****1_234_567_89_0;125000"); 18587 assert(ios.width() == 0); 18588 } 18589 ios.width(25); 18590 internal(ios); 18591 { 18592 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18593 std::string ex(str, iter.base()); 18594 assert(ex == "****1_234_567_89_0;125000"); 18595 assert(ios.width() == 0); 18596 } 18597 } 18598 } 18599 } 18600 showpos(ios); 18601 { 18602 noshowpoint(ios); 18603 { 18604 ios.imbue(lc); 18605 { 18606 ios.width(0); 18607 { 18608 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18609 std::string ex(str, iter.base()); 18610 assert(ex == "+1234567890.125000"); 18611 assert(ios.width() == 0); 18612 } 18613 ios.width(25); 18614 left(ios); 18615 { 18616 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18617 std::string ex(str, iter.base()); 18618 assert(ex == "+1234567890.125000*******"); 18619 assert(ios.width() == 0); 18620 } 18621 ios.width(25); 18622 right(ios); 18623 { 18624 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18625 std::string ex(str, iter.base()); 18626 assert(ex == "*******+1234567890.125000"); 18627 assert(ios.width() == 0); 18628 } 18629 ios.width(25); 18630 internal(ios); 18631 { 18632 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18633 std::string ex(str, iter.base()); 18634 assert(ex == "+*******1234567890.125000"); 18635 assert(ios.width() == 0); 18636 } 18637 } 18638 ios.imbue(lg); 18639 { 18640 ios.width(0); 18641 { 18642 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18643 std::string ex(str, iter.base()); 18644 assert(ex == "+1_234_567_89_0;125000"); 18645 assert(ios.width() == 0); 18646 } 18647 ios.width(25); 18648 left(ios); 18649 { 18650 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18651 std::string ex(str, iter.base()); 18652 assert(ex == "+1_234_567_89_0;125000***"); 18653 assert(ios.width() == 0); 18654 } 18655 ios.width(25); 18656 right(ios); 18657 { 18658 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18659 std::string ex(str, iter.base()); 18660 assert(ex == "***+1_234_567_89_0;125000"); 18661 assert(ios.width() == 0); 18662 } 18663 ios.width(25); 18664 internal(ios); 18665 { 18666 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18667 std::string ex(str, iter.base()); 18668 assert(ex == "+***1_234_567_89_0;125000"); 18669 assert(ios.width() == 0); 18670 } 18671 } 18672 } 18673 showpoint(ios); 18674 { 18675 ios.imbue(lc); 18676 { 18677 ios.width(0); 18678 { 18679 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18680 std::string ex(str, iter.base()); 18681 assert(ex == "+1234567890.125000"); 18682 assert(ios.width() == 0); 18683 } 18684 ios.width(25); 18685 left(ios); 18686 { 18687 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18688 std::string ex(str, iter.base()); 18689 assert(ex == "+1234567890.125000*******"); 18690 assert(ios.width() == 0); 18691 } 18692 ios.width(25); 18693 right(ios); 18694 { 18695 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18696 std::string ex(str, iter.base()); 18697 assert(ex == "*******+1234567890.125000"); 18698 assert(ios.width() == 0); 18699 } 18700 ios.width(25); 18701 internal(ios); 18702 { 18703 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18704 std::string ex(str, iter.base()); 18705 assert(ex == "+*******1234567890.125000"); 18706 assert(ios.width() == 0); 18707 } 18708 } 18709 ios.imbue(lg); 18710 { 18711 ios.width(0); 18712 { 18713 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18714 std::string ex(str, iter.base()); 18715 assert(ex == "+1_234_567_89_0;125000"); 18716 assert(ios.width() == 0); 18717 } 18718 ios.width(25); 18719 left(ios); 18720 { 18721 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18722 std::string ex(str, iter.base()); 18723 assert(ex == "+1_234_567_89_0;125000***"); 18724 assert(ios.width() == 0); 18725 } 18726 ios.width(25); 18727 right(ios); 18728 { 18729 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18730 std::string ex(str, iter.base()); 18731 assert(ex == "***+1_234_567_89_0;125000"); 18732 assert(ios.width() == 0); 18733 } 18734 ios.width(25); 18735 internal(ios); 18736 { 18737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18738 std::string ex(str, iter.base()); 18739 assert(ex == "+***1_234_567_89_0;125000"); 18740 assert(ios.width() == 0); 18741 } 18742 } 18743 } 18744 } 18745 } 18746 uppercase(ios); 18747 { 18748 noshowpos(ios); 18749 { 18750 noshowpoint(ios); 18751 { 18752 ios.imbue(lc); 18753 { 18754 ios.width(0); 18755 { 18756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18757 std::string ex(str, iter.base()); 18758 assert(ex == "1234567890.125000"); 18759 assert(ios.width() == 0); 18760 } 18761 ios.width(25); 18762 left(ios); 18763 { 18764 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18765 std::string ex(str, iter.base()); 18766 assert(ex == "1234567890.125000********"); 18767 assert(ios.width() == 0); 18768 } 18769 ios.width(25); 18770 right(ios); 18771 { 18772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18773 std::string ex(str, iter.base()); 18774 assert(ex == "********1234567890.125000"); 18775 assert(ios.width() == 0); 18776 } 18777 ios.width(25); 18778 internal(ios); 18779 { 18780 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18781 std::string ex(str, iter.base()); 18782 assert(ex == "********1234567890.125000"); 18783 assert(ios.width() == 0); 18784 } 18785 } 18786 ios.imbue(lg); 18787 { 18788 ios.width(0); 18789 { 18790 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18791 std::string ex(str, iter.base()); 18792 assert(ex == "1_234_567_89_0;125000"); 18793 assert(ios.width() == 0); 18794 } 18795 ios.width(25); 18796 left(ios); 18797 { 18798 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18799 std::string ex(str, iter.base()); 18800 assert(ex == "1_234_567_89_0;125000****"); 18801 assert(ios.width() == 0); 18802 } 18803 ios.width(25); 18804 right(ios); 18805 { 18806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18807 std::string ex(str, iter.base()); 18808 assert(ex == "****1_234_567_89_0;125000"); 18809 assert(ios.width() == 0); 18810 } 18811 ios.width(25); 18812 internal(ios); 18813 { 18814 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18815 std::string ex(str, iter.base()); 18816 assert(ex == "****1_234_567_89_0;125000"); 18817 assert(ios.width() == 0); 18818 } 18819 } 18820 } 18821 showpoint(ios); 18822 { 18823 ios.imbue(lc); 18824 { 18825 ios.width(0); 18826 { 18827 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18828 std::string ex(str, iter.base()); 18829 assert(ex == "1234567890.125000"); 18830 assert(ios.width() == 0); 18831 } 18832 ios.width(25); 18833 left(ios); 18834 { 18835 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18836 std::string ex(str, iter.base()); 18837 assert(ex == "1234567890.125000********"); 18838 assert(ios.width() == 0); 18839 } 18840 ios.width(25); 18841 right(ios); 18842 { 18843 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18844 std::string ex(str, iter.base()); 18845 assert(ex == "********1234567890.125000"); 18846 assert(ios.width() == 0); 18847 } 18848 ios.width(25); 18849 internal(ios); 18850 { 18851 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18852 std::string ex(str, iter.base()); 18853 assert(ex == "********1234567890.125000"); 18854 assert(ios.width() == 0); 18855 } 18856 } 18857 ios.imbue(lg); 18858 { 18859 ios.width(0); 18860 { 18861 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18862 std::string ex(str, iter.base()); 18863 assert(ex == "1_234_567_89_0;125000"); 18864 assert(ios.width() == 0); 18865 } 18866 ios.width(25); 18867 left(ios); 18868 { 18869 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18870 std::string ex(str, iter.base()); 18871 assert(ex == "1_234_567_89_0;125000****"); 18872 assert(ios.width() == 0); 18873 } 18874 ios.width(25); 18875 right(ios); 18876 { 18877 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18878 std::string ex(str, iter.base()); 18879 assert(ex == "****1_234_567_89_0;125000"); 18880 assert(ios.width() == 0); 18881 } 18882 ios.width(25); 18883 internal(ios); 18884 { 18885 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18886 std::string ex(str, iter.base()); 18887 assert(ex == "****1_234_567_89_0;125000"); 18888 assert(ios.width() == 0); 18889 } 18890 } 18891 } 18892 } 18893 showpos(ios); 18894 { 18895 noshowpoint(ios); 18896 { 18897 ios.imbue(lc); 18898 { 18899 ios.width(0); 18900 { 18901 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18902 std::string ex(str, iter.base()); 18903 assert(ex == "+1234567890.125000"); 18904 assert(ios.width() == 0); 18905 } 18906 ios.width(25); 18907 left(ios); 18908 { 18909 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18910 std::string ex(str, iter.base()); 18911 assert(ex == "+1234567890.125000*******"); 18912 assert(ios.width() == 0); 18913 } 18914 ios.width(25); 18915 right(ios); 18916 { 18917 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18918 std::string ex(str, iter.base()); 18919 assert(ex == "*******+1234567890.125000"); 18920 assert(ios.width() == 0); 18921 } 18922 ios.width(25); 18923 internal(ios); 18924 { 18925 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18926 std::string ex(str, iter.base()); 18927 assert(ex == "+*******1234567890.125000"); 18928 assert(ios.width() == 0); 18929 } 18930 } 18931 ios.imbue(lg); 18932 { 18933 ios.width(0); 18934 { 18935 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18936 std::string ex(str, iter.base()); 18937 assert(ex == "+1_234_567_89_0;125000"); 18938 assert(ios.width() == 0); 18939 } 18940 ios.width(25); 18941 left(ios); 18942 { 18943 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18944 std::string ex(str, iter.base()); 18945 assert(ex == "+1_234_567_89_0;125000***"); 18946 assert(ios.width() == 0); 18947 } 18948 ios.width(25); 18949 right(ios); 18950 { 18951 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18952 std::string ex(str, iter.base()); 18953 assert(ex == "***+1_234_567_89_0;125000"); 18954 assert(ios.width() == 0); 18955 } 18956 ios.width(25); 18957 internal(ios); 18958 { 18959 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18960 std::string ex(str, iter.base()); 18961 assert(ex == "+***1_234_567_89_0;125000"); 18962 assert(ios.width() == 0); 18963 } 18964 } 18965 } 18966 showpoint(ios); 18967 { 18968 ios.imbue(lc); 18969 { 18970 ios.width(0); 18971 { 18972 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18973 std::string ex(str, iter.base()); 18974 assert(ex == "+1234567890.125000"); 18975 assert(ios.width() == 0); 18976 } 18977 ios.width(25); 18978 left(ios); 18979 { 18980 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18981 std::string ex(str, iter.base()); 18982 assert(ex == "+1234567890.125000*******"); 18983 assert(ios.width() == 0); 18984 } 18985 ios.width(25); 18986 right(ios); 18987 { 18988 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18989 std::string ex(str, iter.base()); 18990 assert(ex == "*******+1234567890.125000"); 18991 assert(ios.width() == 0); 18992 } 18993 ios.width(25); 18994 internal(ios); 18995 { 18996 iter = f.put(output_iterator<char*>(str), ios, '*', v); 18997 std::string ex(str, iter.base()); 18998 assert(ex == "+*******1234567890.125000"); 18999 assert(ios.width() == 0); 19000 } 19001 } 19002 ios.imbue(lg); 19003 { 19004 ios.width(0); 19005 { 19006 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19007 std::string ex(str, iter.base()); 19008 assert(ex == "+1_234_567_89_0;125000"); 19009 assert(ios.width() == 0); 19010 } 19011 ios.width(25); 19012 left(ios); 19013 { 19014 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19015 std::string ex(str, iter.base()); 19016 assert(ex == "+1_234_567_89_0;125000***"); 19017 assert(ios.width() == 0); 19018 } 19019 ios.width(25); 19020 right(ios); 19021 { 19022 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19023 std::string ex(str, iter.base()); 19024 assert(ex == "***+1_234_567_89_0;125000"); 19025 assert(ios.width() == 0); 19026 } 19027 ios.width(25); 19028 internal(ios); 19029 { 19030 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19031 std::string ex(str, iter.base()); 19032 assert(ex == "+***1_234_567_89_0;125000"); 19033 assert(ios.width() == 0); 19034 } 19035 } 19036 } 19037 } 19038 } 19039 } 19040 ios.precision(16); 19041 {} 19042 ios.precision(60); 19043 {} 19044 } 19045 } 19046 } 19047 19048 void test9() 19049 { 19050 char str[200]; 19051 output_iterator<char*> iter; 19052 std::locale lc = std::locale::classic(); 19053 std::locale lg(lc, new my_numpunct); 19054 const my_facet f(1); 19055 { 19056 long double v = -0.; 19057 std::ios ios(0); 19058 scientific(ios); 19059 // %e 19060 { 19061 ios.precision(0); 19062 { 19063 nouppercase(ios); 19064 { 19065 noshowpos(ios); 19066 { 19067 noshowpoint(ios); 19068 { 19069 ios.imbue(lc); 19070 { 19071 ios.width(0); 19072 { 19073 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19074 std::string ex(str, iter.base()); 19075 assert(ex == "-0e+00"); 19076 assert(ios.width() == 0); 19077 } 19078 ios.width(25); 19079 left(ios); 19080 { 19081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19082 std::string ex(str, iter.base()); 19083 assert(ex == "-0e+00*******************"); 19084 assert(ios.width() == 0); 19085 } 19086 ios.width(25); 19087 right(ios); 19088 { 19089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19090 std::string ex(str, iter.base()); 19091 assert(ex == "*******************-0e+00"); 19092 assert(ios.width() == 0); 19093 } 19094 ios.width(25); 19095 internal(ios); 19096 { 19097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19098 std::string ex(str, iter.base()); 19099 assert(ex == "-*******************0e+00"); 19100 assert(ios.width() == 0); 19101 } 19102 } 19103 ios.imbue(lg); 19104 { 19105 ios.width(0); 19106 { 19107 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19108 std::string ex(str, iter.base()); 19109 assert(ex == "-0e+00"); 19110 assert(ios.width() == 0); 19111 } 19112 ios.width(25); 19113 left(ios); 19114 { 19115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19116 std::string ex(str, iter.base()); 19117 assert(ex == "-0e+00*******************"); 19118 assert(ios.width() == 0); 19119 } 19120 ios.width(25); 19121 right(ios); 19122 { 19123 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19124 std::string ex(str, iter.base()); 19125 assert(ex == "*******************-0e+00"); 19126 assert(ios.width() == 0); 19127 } 19128 ios.width(25); 19129 internal(ios); 19130 { 19131 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19132 std::string ex(str, iter.base()); 19133 assert(ex == "-*******************0e+00"); 19134 assert(ios.width() == 0); 19135 } 19136 } 19137 } 19138 showpoint(ios); 19139 { 19140 ios.imbue(lc); 19141 { 19142 ios.width(0); 19143 { 19144 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19145 std::string ex(str, iter.base()); 19146 assert(ex == "-0.e+00"); 19147 assert(ios.width() == 0); 19148 } 19149 ios.width(25); 19150 left(ios); 19151 { 19152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19153 std::string ex(str, iter.base()); 19154 assert(ex == "-0.e+00******************"); 19155 assert(ios.width() == 0); 19156 } 19157 ios.width(25); 19158 right(ios); 19159 { 19160 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19161 std::string ex(str, iter.base()); 19162 assert(ex == "******************-0.e+00"); 19163 assert(ios.width() == 0); 19164 } 19165 ios.width(25); 19166 internal(ios); 19167 { 19168 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19169 std::string ex(str, iter.base()); 19170 assert(ex == "-******************0.e+00"); 19171 assert(ios.width() == 0); 19172 } 19173 } 19174 ios.imbue(lg); 19175 { 19176 ios.width(0); 19177 { 19178 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19179 std::string ex(str, iter.base()); 19180 assert(ex == "-0;e+00"); 19181 assert(ios.width() == 0); 19182 } 19183 ios.width(25); 19184 left(ios); 19185 { 19186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19187 std::string ex(str, iter.base()); 19188 assert(ex == "-0;e+00******************"); 19189 assert(ios.width() == 0); 19190 } 19191 ios.width(25); 19192 right(ios); 19193 { 19194 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19195 std::string ex(str, iter.base()); 19196 assert(ex == "******************-0;e+00"); 19197 assert(ios.width() == 0); 19198 } 19199 ios.width(25); 19200 internal(ios); 19201 { 19202 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19203 std::string ex(str, iter.base()); 19204 assert(ex == "-******************0;e+00"); 19205 assert(ios.width() == 0); 19206 } 19207 } 19208 } 19209 } 19210 showpos(ios); 19211 { 19212 noshowpoint(ios); 19213 { 19214 ios.imbue(lc); 19215 { 19216 ios.width(0); 19217 { 19218 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19219 std::string ex(str, iter.base()); 19220 assert(ex == "-0e+00"); 19221 assert(ios.width() == 0); 19222 } 19223 ios.width(25); 19224 left(ios); 19225 { 19226 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19227 std::string ex(str, iter.base()); 19228 assert(ex == "-0e+00*******************"); 19229 assert(ios.width() == 0); 19230 } 19231 ios.width(25); 19232 right(ios); 19233 { 19234 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19235 std::string ex(str, iter.base()); 19236 assert(ex == "*******************-0e+00"); 19237 assert(ios.width() == 0); 19238 } 19239 ios.width(25); 19240 internal(ios); 19241 { 19242 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19243 std::string ex(str, iter.base()); 19244 assert(ex == "-*******************0e+00"); 19245 assert(ios.width() == 0); 19246 } 19247 } 19248 ios.imbue(lg); 19249 { 19250 ios.width(0); 19251 { 19252 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19253 std::string ex(str, iter.base()); 19254 assert(ex == "-0e+00"); 19255 assert(ios.width() == 0); 19256 } 19257 ios.width(25); 19258 left(ios); 19259 { 19260 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19261 std::string ex(str, iter.base()); 19262 assert(ex == "-0e+00*******************"); 19263 assert(ios.width() == 0); 19264 } 19265 ios.width(25); 19266 right(ios); 19267 { 19268 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19269 std::string ex(str, iter.base()); 19270 assert(ex == "*******************-0e+00"); 19271 assert(ios.width() == 0); 19272 } 19273 ios.width(25); 19274 internal(ios); 19275 { 19276 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19277 std::string ex(str, iter.base()); 19278 assert(ex == "-*******************0e+00"); 19279 assert(ios.width() == 0); 19280 } 19281 } 19282 } 19283 showpoint(ios); 19284 { 19285 ios.imbue(lc); 19286 { 19287 ios.width(0); 19288 { 19289 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19290 std::string ex(str, iter.base()); 19291 assert(ex == "-0.e+00"); 19292 assert(ios.width() == 0); 19293 } 19294 ios.width(25); 19295 left(ios); 19296 { 19297 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19298 std::string ex(str, iter.base()); 19299 assert(ex == "-0.e+00******************"); 19300 assert(ios.width() == 0); 19301 } 19302 ios.width(25); 19303 right(ios); 19304 { 19305 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19306 std::string ex(str, iter.base()); 19307 assert(ex == "******************-0.e+00"); 19308 assert(ios.width() == 0); 19309 } 19310 ios.width(25); 19311 internal(ios); 19312 { 19313 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19314 std::string ex(str, iter.base()); 19315 assert(ex == "-******************0.e+00"); 19316 assert(ios.width() == 0); 19317 } 19318 } 19319 ios.imbue(lg); 19320 { 19321 ios.width(0); 19322 { 19323 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19324 std::string ex(str, iter.base()); 19325 assert(ex == "-0;e+00"); 19326 assert(ios.width() == 0); 19327 } 19328 ios.width(25); 19329 left(ios); 19330 { 19331 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19332 std::string ex(str, iter.base()); 19333 assert(ex == "-0;e+00******************"); 19334 assert(ios.width() == 0); 19335 } 19336 ios.width(25); 19337 right(ios); 19338 { 19339 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19340 std::string ex(str, iter.base()); 19341 assert(ex == "******************-0;e+00"); 19342 assert(ios.width() == 0); 19343 } 19344 ios.width(25); 19345 internal(ios); 19346 { 19347 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19348 std::string ex(str, iter.base()); 19349 assert(ex == "-******************0;e+00"); 19350 assert(ios.width() == 0); 19351 } 19352 } 19353 } 19354 } 19355 } 19356 uppercase(ios); 19357 { 19358 noshowpos(ios); 19359 { 19360 noshowpoint(ios); 19361 { 19362 ios.imbue(lc); 19363 { 19364 ios.width(0); 19365 { 19366 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19367 std::string ex(str, iter.base()); 19368 assert(ex == "-0E+00"); 19369 assert(ios.width() == 0); 19370 } 19371 ios.width(25); 19372 left(ios); 19373 { 19374 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19375 std::string ex(str, iter.base()); 19376 assert(ex == "-0E+00*******************"); 19377 assert(ios.width() == 0); 19378 } 19379 ios.width(25); 19380 right(ios); 19381 { 19382 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19383 std::string ex(str, iter.base()); 19384 assert(ex == "*******************-0E+00"); 19385 assert(ios.width() == 0); 19386 } 19387 ios.width(25); 19388 internal(ios); 19389 { 19390 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19391 std::string ex(str, iter.base()); 19392 assert(ex == "-*******************0E+00"); 19393 assert(ios.width() == 0); 19394 } 19395 } 19396 ios.imbue(lg); 19397 { 19398 ios.width(0); 19399 { 19400 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19401 std::string ex(str, iter.base()); 19402 assert(ex == "-0E+00"); 19403 assert(ios.width() == 0); 19404 } 19405 ios.width(25); 19406 left(ios); 19407 { 19408 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19409 std::string ex(str, iter.base()); 19410 assert(ex == "-0E+00*******************"); 19411 assert(ios.width() == 0); 19412 } 19413 ios.width(25); 19414 right(ios); 19415 { 19416 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19417 std::string ex(str, iter.base()); 19418 assert(ex == "*******************-0E+00"); 19419 assert(ios.width() == 0); 19420 } 19421 ios.width(25); 19422 internal(ios); 19423 { 19424 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19425 std::string ex(str, iter.base()); 19426 assert(ex == "-*******************0E+00"); 19427 assert(ios.width() == 0); 19428 } 19429 } 19430 } 19431 showpoint(ios); 19432 { 19433 ios.imbue(lc); 19434 { 19435 ios.width(0); 19436 { 19437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19438 std::string ex(str, iter.base()); 19439 assert(ex == "-0.E+00"); 19440 assert(ios.width() == 0); 19441 } 19442 ios.width(25); 19443 left(ios); 19444 { 19445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19446 std::string ex(str, iter.base()); 19447 assert(ex == "-0.E+00******************"); 19448 assert(ios.width() == 0); 19449 } 19450 ios.width(25); 19451 right(ios); 19452 { 19453 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19454 std::string ex(str, iter.base()); 19455 assert(ex == "******************-0.E+00"); 19456 assert(ios.width() == 0); 19457 } 19458 ios.width(25); 19459 internal(ios); 19460 { 19461 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19462 std::string ex(str, iter.base()); 19463 assert(ex == "-******************0.E+00"); 19464 assert(ios.width() == 0); 19465 } 19466 } 19467 ios.imbue(lg); 19468 { 19469 ios.width(0); 19470 { 19471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19472 std::string ex(str, iter.base()); 19473 assert(ex == "-0;E+00"); 19474 assert(ios.width() == 0); 19475 } 19476 ios.width(25); 19477 left(ios); 19478 { 19479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19480 std::string ex(str, iter.base()); 19481 assert(ex == "-0;E+00******************"); 19482 assert(ios.width() == 0); 19483 } 19484 ios.width(25); 19485 right(ios); 19486 { 19487 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19488 std::string ex(str, iter.base()); 19489 assert(ex == "******************-0;E+00"); 19490 assert(ios.width() == 0); 19491 } 19492 ios.width(25); 19493 internal(ios); 19494 { 19495 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19496 std::string ex(str, iter.base()); 19497 assert(ex == "-******************0;E+00"); 19498 assert(ios.width() == 0); 19499 } 19500 } 19501 } 19502 } 19503 showpos(ios); 19504 { 19505 noshowpoint(ios); 19506 { 19507 ios.imbue(lc); 19508 { 19509 ios.width(0); 19510 { 19511 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19512 std::string ex(str, iter.base()); 19513 assert(ex == "-0E+00"); 19514 assert(ios.width() == 0); 19515 } 19516 ios.width(25); 19517 left(ios); 19518 { 19519 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19520 std::string ex(str, iter.base()); 19521 assert(ex == "-0E+00*******************"); 19522 assert(ios.width() == 0); 19523 } 19524 ios.width(25); 19525 right(ios); 19526 { 19527 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19528 std::string ex(str, iter.base()); 19529 assert(ex == "*******************-0E+00"); 19530 assert(ios.width() == 0); 19531 } 19532 ios.width(25); 19533 internal(ios); 19534 { 19535 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19536 std::string ex(str, iter.base()); 19537 assert(ex == "-*******************0E+00"); 19538 assert(ios.width() == 0); 19539 } 19540 } 19541 ios.imbue(lg); 19542 { 19543 ios.width(0); 19544 { 19545 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19546 std::string ex(str, iter.base()); 19547 assert(ex == "-0E+00"); 19548 assert(ios.width() == 0); 19549 } 19550 ios.width(25); 19551 left(ios); 19552 { 19553 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19554 std::string ex(str, iter.base()); 19555 assert(ex == "-0E+00*******************"); 19556 assert(ios.width() == 0); 19557 } 19558 ios.width(25); 19559 right(ios); 19560 { 19561 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19562 std::string ex(str, iter.base()); 19563 assert(ex == "*******************-0E+00"); 19564 assert(ios.width() == 0); 19565 } 19566 ios.width(25); 19567 internal(ios); 19568 { 19569 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19570 std::string ex(str, iter.base()); 19571 assert(ex == "-*******************0E+00"); 19572 assert(ios.width() == 0); 19573 } 19574 } 19575 } 19576 showpoint(ios); 19577 { 19578 ios.imbue(lc); 19579 { 19580 ios.width(0); 19581 { 19582 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19583 std::string ex(str, iter.base()); 19584 assert(ex == "-0.E+00"); 19585 assert(ios.width() == 0); 19586 } 19587 ios.width(25); 19588 left(ios); 19589 { 19590 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19591 std::string ex(str, iter.base()); 19592 assert(ex == "-0.E+00******************"); 19593 assert(ios.width() == 0); 19594 } 19595 ios.width(25); 19596 right(ios); 19597 { 19598 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19599 std::string ex(str, iter.base()); 19600 assert(ex == "******************-0.E+00"); 19601 assert(ios.width() == 0); 19602 } 19603 ios.width(25); 19604 internal(ios); 19605 { 19606 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19607 std::string ex(str, iter.base()); 19608 assert(ex == "-******************0.E+00"); 19609 assert(ios.width() == 0); 19610 } 19611 } 19612 ios.imbue(lg); 19613 { 19614 ios.width(0); 19615 { 19616 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19617 std::string ex(str, iter.base()); 19618 assert(ex == "-0;E+00"); 19619 assert(ios.width() == 0); 19620 } 19621 ios.width(25); 19622 left(ios); 19623 { 19624 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19625 std::string ex(str, iter.base()); 19626 assert(ex == "-0;E+00******************"); 19627 assert(ios.width() == 0); 19628 } 19629 ios.width(25); 19630 right(ios); 19631 { 19632 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19633 std::string ex(str, iter.base()); 19634 assert(ex == "******************-0;E+00"); 19635 assert(ios.width() == 0); 19636 } 19637 ios.width(25); 19638 internal(ios); 19639 { 19640 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19641 std::string ex(str, iter.base()); 19642 assert(ex == "-******************0;E+00"); 19643 assert(ios.width() == 0); 19644 } 19645 } 19646 } 19647 } 19648 } 19649 } 19650 ios.precision(1); 19651 { 19652 nouppercase(ios); 19653 { 19654 noshowpos(ios); 19655 { 19656 noshowpoint(ios); 19657 { 19658 ios.imbue(lc); 19659 { 19660 ios.width(0); 19661 { 19662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19663 std::string ex(str, iter.base()); 19664 assert(ex == "-0.0e+00"); 19665 assert(ios.width() == 0); 19666 } 19667 ios.width(25); 19668 left(ios); 19669 { 19670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19671 std::string ex(str, iter.base()); 19672 assert(ex == "-0.0e+00*****************"); 19673 assert(ios.width() == 0); 19674 } 19675 ios.width(25); 19676 right(ios); 19677 { 19678 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19679 std::string ex(str, iter.base()); 19680 assert(ex == "*****************-0.0e+00"); 19681 assert(ios.width() == 0); 19682 } 19683 ios.width(25); 19684 internal(ios); 19685 { 19686 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19687 std::string ex(str, iter.base()); 19688 assert(ex == "-*****************0.0e+00"); 19689 assert(ios.width() == 0); 19690 } 19691 } 19692 ios.imbue(lg); 19693 { 19694 ios.width(0); 19695 { 19696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19697 std::string ex(str, iter.base()); 19698 assert(ex == "-0;0e+00"); 19699 assert(ios.width() == 0); 19700 } 19701 ios.width(25); 19702 left(ios); 19703 { 19704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19705 std::string ex(str, iter.base()); 19706 assert(ex == "-0;0e+00*****************"); 19707 assert(ios.width() == 0); 19708 } 19709 ios.width(25); 19710 right(ios); 19711 { 19712 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19713 std::string ex(str, iter.base()); 19714 assert(ex == "*****************-0;0e+00"); 19715 assert(ios.width() == 0); 19716 } 19717 ios.width(25); 19718 internal(ios); 19719 { 19720 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19721 std::string ex(str, iter.base()); 19722 assert(ex == "-*****************0;0e+00"); 19723 assert(ios.width() == 0); 19724 } 19725 } 19726 } 19727 showpoint(ios); 19728 { 19729 ios.imbue(lc); 19730 { 19731 ios.width(0); 19732 { 19733 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19734 std::string ex(str, iter.base()); 19735 assert(ex == "-0.0e+00"); 19736 assert(ios.width() == 0); 19737 } 19738 ios.width(25); 19739 left(ios); 19740 { 19741 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19742 std::string ex(str, iter.base()); 19743 assert(ex == "-0.0e+00*****************"); 19744 assert(ios.width() == 0); 19745 } 19746 ios.width(25); 19747 right(ios); 19748 { 19749 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19750 std::string ex(str, iter.base()); 19751 assert(ex == "*****************-0.0e+00"); 19752 assert(ios.width() == 0); 19753 } 19754 ios.width(25); 19755 internal(ios); 19756 { 19757 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19758 std::string ex(str, iter.base()); 19759 assert(ex == "-*****************0.0e+00"); 19760 assert(ios.width() == 0); 19761 } 19762 } 19763 ios.imbue(lg); 19764 { 19765 ios.width(0); 19766 { 19767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19768 std::string ex(str, iter.base()); 19769 assert(ex == "-0;0e+00"); 19770 assert(ios.width() == 0); 19771 } 19772 ios.width(25); 19773 left(ios); 19774 { 19775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19776 std::string ex(str, iter.base()); 19777 assert(ex == "-0;0e+00*****************"); 19778 assert(ios.width() == 0); 19779 } 19780 ios.width(25); 19781 right(ios); 19782 { 19783 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19784 std::string ex(str, iter.base()); 19785 assert(ex == "*****************-0;0e+00"); 19786 assert(ios.width() == 0); 19787 } 19788 ios.width(25); 19789 internal(ios); 19790 { 19791 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19792 std::string ex(str, iter.base()); 19793 assert(ex == "-*****************0;0e+00"); 19794 assert(ios.width() == 0); 19795 } 19796 } 19797 } 19798 } 19799 showpos(ios); 19800 { 19801 noshowpoint(ios); 19802 { 19803 ios.imbue(lc); 19804 { 19805 ios.width(0); 19806 { 19807 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19808 std::string ex(str, iter.base()); 19809 assert(ex == "-0.0e+00"); 19810 assert(ios.width() == 0); 19811 } 19812 ios.width(25); 19813 left(ios); 19814 { 19815 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19816 std::string ex(str, iter.base()); 19817 assert(ex == "-0.0e+00*****************"); 19818 assert(ios.width() == 0); 19819 } 19820 ios.width(25); 19821 right(ios); 19822 { 19823 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19824 std::string ex(str, iter.base()); 19825 assert(ex == "*****************-0.0e+00"); 19826 assert(ios.width() == 0); 19827 } 19828 ios.width(25); 19829 internal(ios); 19830 { 19831 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19832 std::string ex(str, iter.base()); 19833 assert(ex == "-*****************0.0e+00"); 19834 assert(ios.width() == 0); 19835 } 19836 } 19837 ios.imbue(lg); 19838 { 19839 ios.width(0); 19840 { 19841 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19842 std::string ex(str, iter.base()); 19843 assert(ex == "-0;0e+00"); 19844 assert(ios.width() == 0); 19845 } 19846 ios.width(25); 19847 left(ios); 19848 { 19849 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19850 std::string ex(str, iter.base()); 19851 assert(ex == "-0;0e+00*****************"); 19852 assert(ios.width() == 0); 19853 } 19854 ios.width(25); 19855 right(ios); 19856 { 19857 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19858 std::string ex(str, iter.base()); 19859 assert(ex == "*****************-0;0e+00"); 19860 assert(ios.width() == 0); 19861 } 19862 ios.width(25); 19863 internal(ios); 19864 { 19865 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19866 std::string ex(str, iter.base()); 19867 assert(ex == "-*****************0;0e+00"); 19868 assert(ios.width() == 0); 19869 } 19870 } 19871 } 19872 showpoint(ios); 19873 { 19874 ios.imbue(lc); 19875 { 19876 ios.width(0); 19877 { 19878 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19879 std::string ex(str, iter.base()); 19880 assert(ex == "-0.0e+00"); 19881 assert(ios.width() == 0); 19882 } 19883 ios.width(25); 19884 left(ios); 19885 { 19886 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19887 std::string ex(str, iter.base()); 19888 assert(ex == "-0.0e+00*****************"); 19889 assert(ios.width() == 0); 19890 } 19891 ios.width(25); 19892 right(ios); 19893 { 19894 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19895 std::string ex(str, iter.base()); 19896 assert(ex == "*****************-0.0e+00"); 19897 assert(ios.width() == 0); 19898 } 19899 ios.width(25); 19900 internal(ios); 19901 { 19902 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19903 std::string ex(str, iter.base()); 19904 assert(ex == "-*****************0.0e+00"); 19905 assert(ios.width() == 0); 19906 } 19907 } 19908 ios.imbue(lg); 19909 { 19910 ios.width(0); 19911 { 19912 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19913 std::string ex(str, iter.base()); 19914 assert(ex == "-0;0e+00"); 19915 assert(ios.width() == 0); 19916 } 19917 ios.width(25); 19918 left(ios); 19919 { 19920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19921 std::string ex(str, iter.base()); 19922 assert(ex == "-0;0e+00*****************"); 19923 assert(ios.width() == 0); 19924 } 19925 ios.width(25); 19926 right(ios); 19927 { 19928 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19929 std::string ex(str, iter.base()); 19930 assert(ex == "*****************-0;0e+00"); 19931 assert(ios.width() == 0); 19932 } 19933 ios.width(25); 19934 internal(ios); 19935 { 19936 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19937 std::string ex(str, iter.base()); 19938 assert(ex == "-*****************0;0e+00"); 19939 assert(ios.width() == 0); 19940 } 19941 } 19942 } 19943 } 19944 } 19945 uppercase(ios); 19946 { 19947 noshowpos(ios); 19948 { 19949 noshowpoint(ios); 19950 { 19951 ios.imbue(lc); 19952 { 19953 ios.width(0); 19954 { 19955 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19956 std::string ex(str, iter.base()); 19957 assert(ex == "-0.0E+00"); 19958 assert(ios.width() == 0); 19959 } 19960 ios.width(25); 19961 left(ios); 19962 { 19963 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19964 std::string ex(str, iter.base()); 19965 assert(ex == "-0.0E+00*****************"); 19966 assert(ios.width() == 0); 19967 } 19968 ios.width(25); 19969 right(ios); 19970 { 19971 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19972 std::string ex(str, iter.base()); 19973 assert(ex == "*****************-0.0E+00"); 19974 assert(ios.width() == 0); 19975 } 19976 ios.width(25); 19977 internal(ios); 19978 { 19979 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19980 std::string ex(str, iter.base()); 19981 assert(ex == "-*****************0.0E+00"); 19982 assert(ios.width() == 0); 19983 } 19984 } 19985 ios.imbue(lg); 19986 { 19987 ios.width(0); 19988 { 19989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19990 std::string ex(str, iter.base()); 19991 assert(ex == "-0;0E+00"); 19992 assert(ios.width() == 0); 19993 } 19994 ios.width(25); 19995 left(ios); 19996 { 19997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 19998 std::string ex(str, iter.base()); 19999 assert(ex == "-0;0E+00*****************"); 20000 assert(ios.width() == 0); 20001 } 20002 ios.width(25); 20003 right(ios); 20004 { 20005 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20006 std::string ex(str, iter.base()); 20007 assert(ex == "*****************-0;0E+00"); 20008 assert(ios.width() == 0); 20009 } 20010 ios.width(25); 20011 internal(ios); 20012 { 20013 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20014 std::string ex(str, iter.base()); 20015 assert(ex == "-*****************0;0E+00"); 20016 assert(ios.width() == 0); 20017 } 20018 } 20019 } 20020 showpoint(ios); 20021 { 20022 ios.imbue(lc); 20023 { 20024 ios.width(0); 20025 { 20026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20027 std::string ex(str, iter.base()); 20028 assert(ex == "-0.0E+00"); 20029 assert(ios.width() == 0); 20030 } 20031 ios.width(25); 20032 left(ios); 20033 { 20034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20035 std::string ex(str, iter.base()); 20036 assert(ex == "-0.0E+00*****************"); 20037 assert(ios.width() == 0); 20038 } 20039 ios.width(25); 20040 right(ios); 20041 { 20042 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20043 std::string ex(str, iter.base()); 20044 assert(ex == "*****************-0.0E+00"); 20045 assert(ios.width() == 0); 20046 } 20047 ios.width(25); 20048 internal(ios); 20049 { 20050 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20051 std::string ex(str, iter.base()); 20052 assert(ex == "-*****************0.0E+00"); 20053 assert(ios.width() == 0); 20054 } 20055 } 20056 ios.imbue(lg); 20057 { 20058 ios.width(0); 20059 { 20060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20061 std::string ex(str, iter.base()); 20062 assert(ex == "-0;0E+00"); 20063 assert(ios.width() == 0); 20064 } 20065 ios.width(25); 20066 left(ios); 20067 { 20068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20069 std::string ex(str, iter.base()); 20070 assert(ex == "-0;0E+00*****************"); 20071 assert(ios.width() == 0); 20072 } 20073 ios.width(25); 20074 right(ios); 20075 { 20076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20077 std::string ex(str, iter.base()); 20078 assert(ex == "*****************-0;0E+00"); 20079 assert(ios.width() == 0); 20080 } 20081 ios.width(25); 20082 internal(ios); 20083 { 20084 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20085 std::string ex(str, iter.base()); 20086 assert(ex == "-*****************0;0E+00"); 20087 assert(ios.width() == 0); 20088 } 20089 } 20090 } 20091 } 20092 showpos(ios); 20093 { 20094 noshowpoint(ios); 20095 { 20096 ios.imbue(lc); 20097 { 20098 ios.width(0); 20099 { 20100 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20101 std::string ex(str, iter.base()); 20102 assert(ex == "-0.0E+00"); 20103 assert(ios.width() == 0); 20104 } 20105 ios.width(25); 20106 left(ios); 20107 { 20108 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20109 std::string ex(str, iter.base()); 20110 assert(ex == "-0.0E+00*****************"); 20111 assert(ios.width() == 0); 20112 } 20113 ios.width(25); 20114 right(ios); 20115 { 20116 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20117 std::string ex(str, iter.base()); 20118 assert(ex == "*****************-0.0E+00"); 20119 assert(ios.width() == 0); 20120 } 20121 ios.width(25); 20122 internal(ios); 20123 { 20124 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20125 std::string ex(str, iter.base()); 20126 assert(ex == "-*****************0.0E+00"); 20127 assert(ios.width() == 0); 20128 } 20129 } 20130 ios.imbue(lg); 20131 { 20132 ios.width(0); 20133 { 20134 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20135 std::string ex(str, iter.base()); 20136 assert(ex == "-0;0E+00"); 20137 assert(ios.width() == 0); 20138 } 20139 ios.width(25); 20140 left(ios); 20141 { 20142 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20143 std::string ex(str, iter.base()); 20144 assert(ex == "-0;0E+00*****************"); 20145 assert(ios.width() == 0); 20146 } 20147 ios.width(25); 20148 right(ios); 20149 { 20150 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20151 std::string ex(str, iter.base()); 20152 assert(ex == "*****************-0;0E+00"); 20153 assert(ios.width() == 0); 20154 } 20155 ios.width(25); 20156 internal(ios); 20157 { 20158 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20159 std::string ex(str, iter.base()); 20160 assert(ex == "-*****************0;0E+00"); 20161 assert(ios.width() == 0); 20162 } 20163 } 20164 } 20165 showpoint(ios); 20166 { 20167 ios.imbue(lc); 20168 { 20169 ios.width(0); 20170 { 20171 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20172 std::string ex(str, iter.base()); 20173 assert(ex == "-0.0E+00"); 20174 assert(ios.width() == 0); 20175 } 20176 ios.width(25); 20177 left(ios); 20178 { 20179 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20180 std::string ex(str, iter.base()); 20181 assert(ex == "-0.0E+00*****************"); 20182 assert(ios.width() == 0); 20183 } 20184 ios.width(25); 20185 right(ios); 20186 { 20187 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20188 std::string ex(str, iter.base()); 20189 assert(ex == "*****************-0.0E+00"); 20190 assert(ios.width() == 0); 20191 } 20192 ios.width(25); 20193 internal(ios); 20194 { 20195 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20196 std::string ex(str, iter.base()); 20197 assert(ex == "-*****************0.0E+00"); 20198 assert(ios.width() == 0); 20199 } 20200 } 20201 ios.imbue(lg); 20202 { 20203 ios.width(0); 20204 { 20205 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20206 std::string ex(str, iter.base()); 20207 assert(ex == "-0;0E+00"); 20208 assert(ios.width() == 0); 20209 } 20210 ios.width(25); 20211 left(ios); 20212 { 20213 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20214 std::string ex(str, iter.base()); 20215 assert(ex == "-0;0E+00*****************"); 20216 assert(ios.width() == 0); 20217 } 20218 ios.width(25); 20219 right(ios); 20220 { 20221 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20222 std::string ex(str, iter.base()); 20223 assert(ex == "*****************-0;0E+00"); 20224 assert(ios.width() == 0); 20225 } 20226 ios.width(25); 20227 internal(ios); 20228 { 20229 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20230 std::string ex(str, iter.base()); 20231 assert(ex == "-*****************0;0E+00"); 20232 assert(ios.width() == 0); 20233 } 20234 } 20235 } 20236 } 20237 } 20238 } 20239 ios.precision(6); 20240 { 20241 nouppercase(ios); 20242 { 20243 noshowpos(ios); 20244 { 20245 noshowpoint(ios); 20246 { 20247 ios.imbue(lc); 20248 { 20249 ios.width(0); 20250 { 20251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20252 std::string ex(str, iter.base()); 20253 assert(ex == "-0.000000e+00"); 20254 assert(ios.width() == 0); 20255 } 20256 ios.width(25); 20257 left(ios); 20258 { 20259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20260 std::string ex(str, iter.base()); 20261 assert(ex == "-0.000000e+00************"); 20262 assert(ios.width() == 0); 20263 } 20264 ios.width(25); 20265 right(ios); 20266 { 20267 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20268 std::string ex(str, iter.base()); 20269 assert(ex == "************-0.000000e+00"); 20270 assert(ios.width() == 0); 20271 } 20272 ios.width(25); 20273 internal(ios); 20274 { 20275 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20276 std::string ex(str, iter.base()); 20277 assert(ex == "-************0.000000e+00"); 20278 assert(ios.width() == 0); 20279 } 20280 } 20281 ios.imbue(lg); 20282 { 20283 ios.width(0); 20284 { 20285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20286 std::string ex(str, iter.base()); 20287 assert(ex == "-0;000000e+00"); 20288 assert(ios.width() == 0); 20289 } 20290 ios.width(25); 20291 left(ios); 20292 { 20293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20294 std::string ex(str, iter.base()); 20295 assert(ex == "-0;000000e+00************"); 20296 assert(ios.width() == 0); 20297 } 20298 ios.width(25); 20299 right(ios); 20300 { 20301 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20302 std::string ex(str, iter.base()); 20303 assert(ex == "************-0;000000e+00"); 20304 assert(ios.width() == 0); 20305 } 20306 ios.width(25); 20307 internal(ios); 20308 { 20309 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20310 std::string ex(str, iter.base()); 20311 assert(ex == "-************0;000000e+00"); 20312 assert(ios.width() == 0); 20313 } 20314 } 20315 } 20316 showpoint(ios); 20317 { 20318 ios.imbue(lc); 20319 { 20320 ios.width(0); 20321 { 20322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20323 std::string ex(str, iter.base()); 20324 assert(ex == "-0.000000e+00"); 20325 assert(ios.width() == 0); 20326 } 20327 ios.width(25); 20328 left(ios); 20329 { 20330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20331 std::string ex(str, iter.base()); 20332 assert(ex == "-0.000000e+00************"); 20333 assert(ios.width() == 0); 20334 } 20335 ios.width(25); 20336 right(ios); 20337 { 20338 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20339 std::string ex(str, iter.base()); 20340 assert(ex == "************-0.000000e+00"); 20341 assert(ios.width() == 0); 20342 } 20343 ios.width(25); 20344 internal(ios); 20345 { 20346 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20347 std::string ex(str, iter.base()); 20348 assert(ex == "-************0.000000e+00"); 20349 assert(ios.width() == 0); 20350 } 20351 } 20352 ios.imbue(lg); 20353 { 20354 ios.width(0); 20355 { 20356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20357 std::string ex(str, iter.base()); 20358 assert(ex == "-0;000000e+00"); 20359 assert(ios.width() == 0); 20360 } 20361 ios.width(25); 20362 left(ios); 20363 { 20364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20365 std::string ex(str, iter.base()); 20366 assert(ex == "-0;000000e+00************"); 20367 assert(ios.width() == 0); 20368 } 20369 ios.width(25); 20370 right(ios); 20371 { 20372 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20373 std::string ex(str, iter.base()); 20374 assert(ex == "************-0;000000e+00"); 20375 assert(ios.width() == 0); 20376 } 20377 ios.width(25); 20378 internal(ios); 20379 { 20380 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20381 std::string ex(str, iter.base()); 20382 assert(ex == "-************0;000000e+00"); 20383 assert(ios.width() == 0); 20384 } 20385 } 20386 } 20387 } 20388 showpos(ios); 20389 { 20390 noshowpoint(ios); 20391 { 20392 ios.imbue(lc); 20393 { 20394 ios.width(0); 20395 { 20396 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20397 std::string ex(str, iter.base()); 20398 assert(ex == "-0.000000e+00"); 20399 assert(ios.width() == 0); 20400 } 20401 ios.width(25); 20402 left(ios); 20403 { 20404 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20405 std::string ex(str, iter.base()); 20406 assert(ex == "-0.000000e+00************"); 20407 assert(ios.width() == 0); 20408 } 20409 ios.width(25); 20410 right(ios); 20411 { 20412 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20413 std::string ex(str, iter.base()); 20414 assert(ex == "************-0.000000e+00"); 20415 assert(ios.width() == 0); 20416 } 20417 ios.width(25); 20418 internal(ios); 20419 { 20420 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20421 std::string ex(str, iter.base()); 20422 assert(ex == "-************0.000000e+00"); 20423 assert(ios.width() == 0); 20424 } 20425 } 20426 ios.imbue(lg); 20427 { 20428 ios.width(0); 20429 { 20430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20431 std::string ex(str, iter.base()); 20432 assert(ex == "-0;000000e+00"); 20433 assert(ios.width() == 0); 20434 } 20435 ios.width(25); 20436 left(ios); 20437 { 20438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20439 std::string ex(str, iter.base()); 20440 assert(ex == "-0;000000e+00************"); 20441 assert(ios.width() == 0); 20442 } 20443 ios.width(25); 20444 right(ios); 20445 { 20446 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20447 std::string ex(str, iter.base()); 20448 assert(ex == "************-0;000000e+00"); 20449 assert(ios.width() == 0); 20450 } 20451 ios.width(25); 20452 internal(ios); 20453 { 20454 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20455 std::string ex(str, iter.base()); 20456 assert(ex == "-************0;000000e+00"); 20457 assert(ios.width() == 0); 20458 } 20459 } 20460 } 20461 showpoint(ios); 20462 { 20463 ios.imbue(lc); 20464 { 20465 ios.width(0); 20466 { 20467 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20468 std::string ex(str, iter.base()); 20469 assert(ex == "-0.000000e+00"); 20470 assert(ios.width() == 0); 20471 } 20472 ios.width(25); 20473 left(ios); 20474 { 20475 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20476 std::string ex(str, iter.base()); 20477 assert(ex == "-0.000000e+00************"); 20478 assert(ios.width() == 0); 20479 } 20480 ios.width(25); 20481 right(ios); 20482 { 20483 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20484 std::string ex(str, iter.base()); 20485 assert(ex == "************-0.000000e+00"); 20486 assert(ios.width() == 0); 20487 } 20488 ios.width(25); 20489 internal(ios); 20490 { 20491 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20492 std::string ex(str, iter.base()); 20493 assert(ex == "-************0.000000e+00"); 20494 assert(ios.width() == 0); 20495 } 20496 } 20497 ios.imbue(lg); 20498 { 20499 ios.width(0); 20500 { 20501 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20502 std::string ex(str, iter.base()); 20503 assert(ex == "-0;000000e+00"); 20504 assert(ios.width() == 0); 20505 } 20506 ios.width(25); 20507 left(ios); 20508 { 20509 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20510 std::string ex(str, iter.base()); 20511 assert(ex == "-0;000000e+00************"); 20512 assert(ios.width() == 0); 20513 } 20514 ios.width(25); 20515 right(ios); 20516 { 20517 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20518 std::string ex(str, iter.base()); 20519 assert(ex == "************-0;000000e+00"); 20520 assert(ios.width() == 0); 20521 } 20522 ios.width(25); 20523 internal(ios); 20524 { 20525 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20526 std::string ex(str, iter.base()); 20527 assert(ex == "-************0;000000e+00"); 20528 assert(ios.width() == 0); 20529 } 20530 } 20531 } 20532 } 20533 } 20534 uppercase(ios); 20535 { 20536 noshowpos(ios); 20537 { 20538 noshowpoint(ios); 20539 { 20540 ios.imbue(lc); 20541 { 20542 ios.width(0); 20543 { 20544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20545 std::string ex(str, iter.base()); 20546 assert(ex == "-0.000000E+00"); 20547 assert(ios.width() == 0); 20548 } 20549 ios.width(25); 20550 left(ios); 20551 { 20552 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20553 std::string ex(str, iter.base()); 20554 assert(ex == "-0.000000E+00************"); 20555 assert(ios.width() == 0); 20556 } 20557 ios.width(25); 20558 right(ios); 20559 { 20560 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20561 std::string ex(str, iter.base()); 20562 assert(ex == "************-0.000000E+00"); 20563 assert(ios.width() == 0); 20564 } 20565 ios.width(25); 20566 internal(ios); 20567 { 20568 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20569 std::string ex(str, iter.base()); 20570 assert(ex == "-************0.000000E+00"); 20571 assert(ios.width() == 0); 20572 } 20573 } 20574 ios.imbue(lg); 20575 { 20576 ios.width(0); 20577 { 20578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20579 std::string ex(str, iter.base()); 20580 assert(ex == "-0;000000E+00"); 20581 assert(ios.width() == 0); 20582 } 20583 ios.width(25); 20584 left(ios); 20585 { 20586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20587 std::string ex(str, iter.base()); 20588 assert(ex == "-0;000000E+00************"); 20589 assert(ios.width() == 0); 20590 } 20591 ios.width(25); 20592 right(ios); 20593 { 20594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20595 std::string ex(str, iter.base()); 20596 assert(ex == "************-0;000000E+00"); 20597 assert(ios.width() == 0); 20598 } 20599 ios.width(25); 20600 internal(ios); 20601 { 20602 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20603 std::string ex(str, iter.base()); 20604 assert(ex == "-************0;000000E+00"); 20605 assert(ios.width() == 0); 20606 } 20607 } 20608 } 20609 showpoint(ios); 20610 { 20611 ios.imbue(lc); 20612 { 20613 ios.width(0); 20614 { 20615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20616 std::string ex(str, iter.base()); 20617 assert(ex == "-0.000000E+00"); 20618 assert(ios.width() == 0); 20619 } 20620 ios.width(25); 20621 left(ios); 20622 { 20623 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20624 std::string ex(str, iter.base()); 20625 assert(ex == "-0.000000E+00************"); 20626 assert(ios.width() == 0); 20627 } 20628 ios.width(25); 20629 right(ios); 20630 { 20631 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20632 std::string ex(str, iter.base()); 20633 assert(ex == "************-0.000000E+00"); 20634 assert(ios.width() == 0); 20635 } 20636 ios.width(25); 20637 internal(ios); 20638 { 20639 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20640 std::string ex(str, iter.base()); 20641 assert(ex == "-************0.000000E+00"); 20642 assert(ios.width() == 0); 20643 } 20644 } 20645 ios.imbue(lg); 20646 { 20647 ios.width(0); 20648 { 20649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20650 std::string ex(str, iter.base()); 20651 assert(ex == "-0;000000E+00"); 20652 assert(ios.width() == 0); 20653 } 20654 ios.width(25); 20655 left(ios); 20656 { 20657 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20658 std::string ex(str, iter.base()); 20659 assert(ex == "-0;000000E+00************"); 20660 assert(ios.width() == 0); 20661 } 20662 ios.width(25); 20663 right(ios); 20664 { 20665 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20666 std::string ex(str, iter.base()); 20667 assert(ex == "************-0;000000E+00"); 20668 assert(ios.width() == 0); 20669 } 20670 ios.width(25); 20671 internal(ios); 20672 { 20673 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20674 std::string ex(str, iter.base()); 20675 assert(ex == "-************0;000000E+00"); 20676 assert(ios.width() == 0); 20677 } 20678 } 20679 } 20680 } 20681 showpos(ios); 20682 { 20683 noshowpoint(ios); 20684 { 20685 ios.imbue(lc); 20686 { 20687 ios.width(0); 20688 { 20689 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20690 std::string ex(str, iter.base()); 20691 assert(ex == "-0.000000E+00"); 20692 assert(ios.width() == 0); 20693 } 20694 ios.width(25); 20695 left(ios); 20696 { 20697 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20698 std::string ex(str, iter.base()); 20699 assert(ex == "-0.000000E+00************"); 20700 assert(ios.width() == 0); 20701 } 20702 ios.width(25); 20703 right(ios); 20704 { 20705 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20706 std::string ex(str, iter.base()); 20707 assert(ex == "************-0.000000E+00"); 20708 assert(ios.width() == 0); 20709 } 20710 ios.width(25); 20711 internal(ios); 20712 { 20713 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20714 std::string ex(str, iter.base()); 20715 assert(ex == "-************0.000000E+00"); 20716 assert(ios.width() == 0); 20717 } 20718 } 20719 ios.imbue(lg); 20720 { 20721 ios.width(0); 20722 { 20723 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20724 std::string ex(str, iter.base()); 20725 assert(ex == "-0;000000E+00"); 20726 assert(ios.width() == 0); 20727 } 20728 ios.width(25); 20729 left(ios); 20730 { 20731 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20732 std::string ex(str, iter.base()); 20733 assert(ex == "-0;000000E+00************"); 20734 assert(ios.width() == 0); 20735 } 20736 ios.width(25); 20737 right(ios); 20738 { 20739 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20740 std::string ex(str, iter.base()); 20741 assert(ex == "************-0;000000E+00"); 20742 assert(ios.width() == 0); 20743 } 20744 ios.width(25); 20745 internal(ios); 20746 { 20747 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20748 std::string ex(str, iter.base()); 20749 assert(ex == "-************0;000000E+00"); 20750 assert(ios.width() == 0); 20751 } 20752 } 20753 } 20754 showpoint(ios); 20755 { 20756 ios.imbue(lc); 20757 { 20758 ios.width(0); 20759 { 20760 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20761 std::string ex(str, iter.base()); 20762 assert(ex == "-0.000000E+00"); 20763 assert(ios.width() == 0); 20764 } 20765 ios.width(25); 20766 left(ios); 20767 { 20768 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20769 std::string ex(str, iter.base()); 20770 assert(ex == "-0.000000E+00************"); 20771 assert(ios.width() == 0); 20772 } 20773 ios.width(25); 20774 right(ios); 20775 { 20776 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20777 std::string ex(str, iter.base()); 20778 assert(ex == "************-0.000000E+00"); 20779 assert(ios.width() == 0); 20780 } 20781 ios.width(25); 20782 internal(ios); 20783 { 20784 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20785 std::string ex(str, iter.base()); 20786 assert(ex == "-************0.000000E+00"); 20787 assert(ios.width() == 0); 20788 } 20789 } 20790 ios.imbue(lg); 20791 { 20792 ios.width(0); 20793 { 20794 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20795 std::string ex(str, iter.base()); 20796 assert(ex == "-0;000000E+00"); 20797 assert(ios.width() == 0); 20798 } 20799 ios.width(25); 20800 left(ios); 20801 { 20802 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20803 std::string ex(str, iter.base()); 20804 assert(ex == "-0;000000E+00************"); 20805 assert(ios.width() == 0); 20806 } 20807 ios.width(25); 20808 right(ios); 20809 { 20810 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20811 std::string ex(str, iter.base()); 20812 assert(ex == "************-0;000000E+00"); 20813 assert(ios.width() == 0); 20814 } 20815 ios.width(25); 20816 internal(ios); 20817 { 20818 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20819 std::string ex(str, iter.base()); 20820 assert(ex == "-************0;000000E+00"); 20821 assert(ios.width() == 0); 20822 } 20823 } 20824 } 20825 } 20826 } 20827 } 20828 ios.precision(16); 20829 { 20830 } 20831 ios.precision(60); 20832 { 20833 } 20834 } 20835 } 20836 } 20837 20838 void test10() 20839 { 20840 char str[200]; 20841 output_iterator<char*> iter; 20842 std::locale lc = std::locale::classic(); 20843 std::locale lg(lc, new my_numpunct); 20844 const my_facet f(1); 20845 { 20846 long double v = 1234567890.125; 20847 std::ios ios(0); 20848 scientific(ios); 20849 // %e 20850 { 20851 ios.precision(0); 20852 { 20853 nouppercase(ios); 20854 { 20855 noshowpos(ios); 20856 { 20857 noshowpoint(ios); 20858 { 20859 ios.imbue(lc); 20860 { 20861 ios.width(0); 20862 { 20863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20864 std::string ex(str, iter.base()); 20865 assert(ex == "1e+09"); 20866 assert(ios.width() == 0); 20867 } 20868 ios.width(25); 20869 left(ios); 20870 { 20871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20872 std::string ex(str, iter.base()); 20873 assert(ex == "1e+09********************"); 20874 assert(ios.width() == 0); 20875 } 20876 ios.width(25); 20877 right(ios); 20878 { 20879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20880 std::string ex(str, iter.base()); 20881 assert(ex == "********************1e+09"); 20882 assert(ios.width() == 0); 20883 } 20884 ios.width(25); 20885 internal(ios); 20886 { 20887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20888 std::string ex(str, iter.base()); 20889 assert(ex == "********************1e+09"); 20890 assert(ios.width() == 0); 20891 } 20892 } 20893 ios.imbue(lg); 20894 { 20895 ios.width(0); 20896 { 20897 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20898 std::string ex(str, iter.base()); 20899 assert(ex == "1e+09"); 20900 assert(ios.width() == 0); 20901 } 20902 ios.width(25); 20903 left(ios); 20904 { 20905 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20906 std::string ex(str, iter.base()); 20907 assert(ex == "1e+09********************"); 20908 assert(ios.width() == 0); 20909 } 20910 ios.width(25); 20911 right(ios); 20912 { 20913 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20914 std::string ex(str, iter.base()); 20915 assert(ex == "********************1e+09"); 20916 assert(ios.width() == 0); 20917 } 20918 ios.width(25); 20919 internal(ios); 20920 { 20921 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20922 std::string ex(str, iter.base()); 20923 assert(ex == "********************1e+09"); 20924 assert(ios.width() == 0); 20925 } 20926 } 20927 } 20928 showpoint(ios); 20929 { 20930 ios.imbue(lc); 20931 { 20932 ios.width(0); 20933 { 20934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20935 std::string ex(str, iter.base()); 20936 assert(ex == "1.e+09"); 20937 assert(ios.width() == 0); 20938 } 20939 ios.width(25); 20940 left(ios); 20941 { 20942 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20943 std::string ex(str, iter.base()); 20944 assert(ex == "1.e+09*******************"); 20945 assert(ios.width() == 0); 20946 } 20947 ios.width(25); 20948 right(ios); 20949 { 20950 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20951 std::string ex(str, iter.base()); 20952 assert(ex == "*******************1.e+09"); 20953 assert(ios.width() == 0); 20954 } 20955 ios.width(25); 20956 internal(ios); 20957 { 20958 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20959 std::string ex(str, iter.base()); 20960 assert(ex == "*******************1.e+09"); 20961 assert(ios.width() == 0); 20962 } 20963 } 20964 ios.imbue(lg); 20965 { 20966 ios.width(0); 20967 { 20968 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20969 std::string ex(str, iter.base()); 20970 assert(ex == "1;e+09"); 20971 assert(ios.width() == 0); 20972 } 20973 ios.width(25); 20974 left(ios); 20975 { 20976 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20977 std::string ex(str, iter.base()); 20978 assert(ex == "1;e+09*******************"); 20979 assert(ios.width() == 0); 20980 } 20981 ios.width(25); 20982 right(ios); 20983 { 20984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20985 std::string ex(str, iter.base()); 20986 assert(ex == "*******************1;e+09"); 20987 assert(ios.width() == 0); 20988 } 20989 ios.width(25); 20990 internal(ios); 20991 { 20992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 20993 std::string ex(str, iter.base()); 20994 assert(ex == "*******************1;e+09"); 20995 assert(ios.width() == 0); 20996 } 20997 } 20998 } 20999 } 21000 showpos(ios); 21001 { 21002 noshowpoint(ios); 21003 { 21004 ios.imbue(lc); 21005 { 21006 ios.width(0); 21007 { 21008 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21009 std::string ex(str, iter.base()); 21010 assert(ex == "+1e+09"); 21011 assert(ios.width() == 0); 21012 } 21013 ios.width(25); 21014 left(ios); 21015 { 21016 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21017 std::string ex(str, iter.base()); 21018 assert(ex == "+1e+09*******************"); 21019 assert(ios.width() == 0); 21020 } 21021 ios.width(25); 21022 right(ios); 21023 { 21024 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21025 std::string ex(str, iter.base()); 21026 assert(ex == "*******************+1e+09"); 21027 assert(ios.width() == 0); 21028 } 21029 ios.width(25); 21030 internal(ios); 21031 { 21032 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21033 std::string ex(str, iter.base()); 21034 assert(ex == "+*******************1e+09"); 21035 assert(ios.width() == 0); 21036 } 21037 } 21038 ios.imbue(lg); 21039 { 21040 ios.width(0); 21041 { 21042 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21043 std::string ex(str, iter.base()); 21044 assert(ex == "+1e+09"); 21045 assert(ios.width() == 0); 21046 } 21047 ios.width(25); 21048 left(ios); 21049 { 21050 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21051 std::string ex(str, iter.base()); 21052 assert(ex == "+1e+09*******************"); 21053 assert(ios.width() == 0); 21054 } 21055 ios.width(25); 21056 right(ios); 21057 { 21058 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21059 std::string ex(str, iter.base()); 21060 assert(ex == "*******************+1e+09"); 21061 assert(ios.width() == 0); 21062 } 21063 ios.width(25); 21064 internal(ios); 21065 { 21066 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21067 std::string ex(str, iter.base()); 21068 assert(ex == "+*******************1e+09"); 21069 assert(ios.width() == 0); 21070 } 21071 } 21072 } 21073 showpoint(ios); 21074 { 21075 ios.imbue(lc); 21076 { 21077 ios.width(0); 21078 { 21079 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21080 std::string ex(str, iter.base()); 21081 assert(ex == "+1.e+09"); 21082 assert(ios.width() == 0); 21083 } 21084 ios.width(25); 21085 left(ios); 21086 { 21087 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21088 std::string ex(str, iter.base()); 21089 assert(ex == "+1.e+09******************"); 21090 assert(ios.width() == 0); 21091 } 21092 ios.width(25); 21093 right(ios); 21094 { 21095 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21096 std::string ex(str, iter.base()); 21097 assert(ex == "******************+1.e+09"); 21098 assert(ios.width() == 0); 21099 } 21100 ios.width(25); 21101 internal(ios); 21102 { 21103 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21104 std::string ex(str, iter.base()); 21105 assert(ex == "+******************1.e+09"); 21106 assert(ios.width() == 0); 21107 } 21108 } 21109 ios.imbue(lg); 21110 { 21111 ios.width(0); 21112 { 21113 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21114 std::string ex(str, iter.base()); 21115 assert(ex == "+1;e+09"); 21116 assert(ios.width() == 0); 21117 } 21118 ios.width(25); 21119 left(ios); 21120 { 21121 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21122 std::string ex(str, iter.base()); 21123 assert(ex == "+1;e+09******************"); 21124 assert(ios.width() == 0); 21125 } 21126 ios.width(25); 21127 right(ios); 21128 { 21129 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21130 std::string ex(str, iter.base()); 21131 assert(ex == "******************+1;e+09"); 21132 assert(ios.width() == 0); 21133 } 21134 ios.width(25); 21135 internal(ios); 21136 { 21137 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21138 std::string ex(str, iter.base()); 21139 assert(ex == "+******************1;e+09"); 21140 assert(ios.width() == 0); 21141 } 21142 } 21143 } 21144 } 21145 } 21146 uppercase(ios); 21147 { 21148 noshowpos(ios); 21149 { 21150 noshowpoint(ios); 21151 { 21152 ios.imbue(lc); 21153 { 21154 ios.width(0); 21155 { 21156 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21157 std::string ex(str, iter.base()); 21158 assert(ex == "1E+09"); 21159 assert(ios.width() == 0); 21160 } 21161 ios.width(25); 21162 left(ios); 21163 { 21164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21165 std::string ex(str, iter.base()); 21166 assert(ex == "1E+09********************"); 21167 assert(ios.width() == 0); 21168 } 21169 ios.width(25); 21170 right(ios); 21171 { 21172 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21173 std::string ex(str, iter.base()); 21174 assert(ex == "********************1E+09"); 21175 assert(ios.width() == 0); 21176 } 21177 ios.width(25); 21178 internal(ios); 21179 { 21180 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21181 std::string ex(str, iter.base()); 21182 assert(ex == "********************1E+09"); 21183 assert(ios.width() == 0); 21184 } 21185 } 21186 ios.imbue(lg); 21187 { 21188 ios.width(0); 21189 { 21190 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21191 std::string ex(str, iter.base()); 21192 assert(ex == "1E+09"); 21193 assert(ios.width() == 0); 21194 } 21195 ios.width(25); 21196 left(ios); 21197 { 21198 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21199 std::string ex(str, iter.base()); 21200 assert(ex == "1E+09********************"); 21201 assert(ios.width() == 0); 21202 } 21203 ios.width(25); 21204 right(ios); 21205 { 21206 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21207 std::string ex(str, iter.base()); 21208 assert(ex == "********************1E+09"); 21209 assert(ios.width() == 0); 21210 } 21211 ios.width(25); 21212 internal(ios); 21213 { 21214 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21215 std::string ex(str, iter.base()); 21216 assert(ex == "********************1E+09"); 21217 assert(ios.width() == 0); 21218 } 21219 } 21220 } 21221 showpoint(ios); 21222 { 21223 ios.imbue(lc); 21224 { 21225 ios.width(0); 21226 { 21227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21228 std::string ex(str, iter.base()); 21229 assert(ex == "1.E+09"); 21230 assert(ios.width() == 0); 21231 } 21232 ios.width(25); 21233 left(ios); 21234 { 21235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21236 std::string ex(str, iter.base()); 21237 assert(ex == "1.E+09*******************"); 21238 assert(ios.width() == 0); 21239 } 21240 ios.width(25); 21241 right(ios); 21242 { 21243 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21244 std::string ex(str, iter.base()); 21245 assert(ex == "*******************1.E+09"); 21246 assert(ios.width() == 0); 21247 } 21248 ios.width(25); 21249 internal(ios); 21250 { 21251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21252 std::string ex(str, iter.base()); 21253 assert(ex == "*******************1.E+09"); 21254 assert(ios.width() == 0); 21255 } 21256 } 21257 ios.imbue(lg); 21258 { 21259 ios.width(0); 21260 { 21261 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21262 std::string ex(str, iter.base()); 21263 assert(ex == "1;E+09"); 21264 assert(ios.width() == 0); 21265 } 21266 ios.width(25); 21267 left(ios); 21268 { 21269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21270 std::string ex(str, iter.base()); 21271 assert(ex == "1;E+09*******************"); 21272 assert(ios.width() == 0); 21273 } 21274 ios.width(25); 21275 right(ios); 21276 { 21277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21278 std::string ex(str, iter.base()); 21279 assert(ex == "*******************1;E+09"); 21280 assert(ios.width() == 0); 21281 } 21282 ios.width(25); 21283 internal(ios); 21284 { 21285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21286 std::string ex(str, iter.base()); 21287 assert(ex == "*******************1;E+09"); 21288 assert(ios.width() == 0); 21289 } 21290 } 21291 } 21292 } 21293 showpos(ios); 21294 { 21295 noshowpoint(ios); 21296 { 21297 ios.imbue(lc); 21298 { 21299 ios.width(0); 21300 { 21301 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21302 std::string ex(str, iter.base()); 21303 assert(ex == "+1E+09"); 21304 assert(ios.width() == 0); 21305 } 21306 ios.width(25); 21307 left(ios); 21308 { 21309 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21310 std::string ex(str, iter.base()); 21311 assert(ex == "+1E+09*******************"); 21312 assert(ios.width() == 0); 21313 } 21314 ios.width(25); 21315 right(ios); 21316 { 21317 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21318 std::string ex(str, iter.base()); 21319 assert(ex == "*******************+1E+09"); 21320 assert(ios.width() == 0); 21321 } 21322 ios.width(25); 21323 internal(ios); 21324 { 21325 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21326 std::string ex(str, iter.base()); 21327 assert(ex == "+*******************1E+09"); 21328 assert(ios.width() == 0); 21329 } 21330 } 21331 ios.imbue(lg); 21332 { 21333 ios.width(0); 21334 { 21335 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21336 std::string ex(str, iter.base()); 21337 assert(ex == "+1E+09"); 21338 assert(ios.width() == 0); 21339 } 21340 ios.width(25); 21341 left(ios); 21342 { 21343 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21344 std::string ex(str, iter.base()); 21345 assert(ex == "+1E+09*******************"); 21346 assert(ios.width() == 0); 21347 } 21348 ios.width(25); 21349 right(ios); 21350 { 21351 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21352 std::string ex(str, iter.base()); 21353 assert(ex == "*******************+1E+09"); 21354 assert(ios.width() == 0); 21355 } 21356 ios.width(25); 21357 internal(ios); 21358 { 21359 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21360 std::string ex(str, iter.base()); 21361 assert(ex == "+*******************1E+09"); 21362 assert(ios.width() == 0); 21363 } 21364 } 21365 } 21366 showpoint(ios); 21367 { 21368 ios.imbue(lc); 21369 { 21370 ios.width(0); 21371 { 21372 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21373 std::string ex(str, iter.base()); 21374 assert(ex == "+1.E+09"); 21375 assert(ios.width() == 0); 21376 } 21377 ios.width(25); 21378 left(ios); 21379 { 21380 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21381 std::string ex(str, iter.base()); 21382 assert(ex == "+1.E+09******************"); 21383 assert(ios.width() == 0); 21384 } 21385 ios.width(25); 21386 right(ios); 21387 { 21388 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21389 std::string ex(str, iter.base()); 21390 assert(ex == "******************+1.E+09"); 21391 assert(ios.width() == 0); 21392 } 21393 ios.width(25); 21394 internal(ios); 21395 { 21396 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21397 std::string ex(str, iter.base()); 21398 assert(ex == "+******************1.E+09"); 21399 assert(ios.width() == 0); 21400 } 21401 } 21402 ios.imbue(lg); 21403 { 21404 ios.width(0); 21405 { 21406 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21407 std::string ex(str, iter.base()); 21408 assert(ex == "+1;E+09"); 21409 assert(ios.width() == 0); 21410 } 21411 ios.width(25); 21412 left(ios); 21413 { 21414 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21415 std::string ex(str, iter.base()); 21416 assert(ex == "+1;E+09******************"); 21417 assert(ios.width() == 0); 21418 } 21419 ios.width(25); 21420 right(ios); 21421 { 21422 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21423 std::string ex(str, iter.base()); 21424 assert(ex == "******************+1;E+09"); 21425 assert(ios.width() == 0); 21426 } 21427 ios.width(25); 21428 internal(ios); 21429 { 21430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21431 std::string ex(str, iter.base()); 21432 assert(ex == "+******************1;E+09"); 21433 assert(ios.width() == 0); 21434 } 21435 } 21436 } 21437 } 21438 } 21439 } 21440 ios.precision(1); 21441 { 21442 nouppercase(ios); 21443 { 21444 noshowpos(ios); 21445 { 21446 noshowpoint(ios); 21447 { 21448 ios.imbue(lc); 21449 { 21450 ios.width(0); 21451 { 21452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21453 std::string ex(str, iter.base()); 21454 assert(ex == "1.2e+09"); 21455 assert(ios.width() == 0); 21456 } 21457 ios.width(25); 21458 left(ios); 21459 { 21460 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21461 std::string ex(str, iter.base()); 21462 assert(ex == "1.2e+09******************"); 21463 assert(ios.width() == 0); 21464 } 21465 ios.width(25); 21466 right(ios); 21467 { 21468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21469 std::string ex(str, iter.base()); 21470 assert(ex == "******************1.2e+09"); 21471 assert(ios.width() == 0); 21472 } 21473 ios.width(25); 21474 internal(ios); 21475 { 21476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21477 std::string ex(str, iter.base()); 21478 assert(ex == "******************1.2e+09"); 21479 assert(ios.width() == 0); 21480 } 21481 } 21482 ios.imbue(lg); 21483 { 21484 ios.width(0); 21485 { 21486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21487 std::string ex(str, iter.base()); 21488 assert(ex == "1;2e+09"); 21489 assert(ios.width() == 0); 21490 } 21491 ios.width(25); 21492 left(ios); 21493 { 21494 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21495 std::string ex(str, iter.base()); 21496 assert(ex == "1;2e+09******************"); 21497 assert(ios.width() == 0); 21498 } 21499 ios.width(25); 21500 right(ios); 21501 { 21502 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21503 std::string ex(str, iter.base()); 21504 assert(ex == "******************1;2e+09"); 21505 assert(ios.width() == 0); 21506 } 21507 ios.width(25); 21508 internal(ios); 21509 { 21510 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21511 std::string ex(str, iter.base()); 21512 assert(ex == "******************1;2e+09"); 21513 assert(ios.width() == 0); 21514 } 21515 } 21516 } 21517 showpoint(ios); 21518 { 21519 ios.imbue(lc); 21520 { 21521 ios.width(0); 21522 { 21523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21524 std::string ex(str, iter.base()); 21525 assert(ex == "1.2e+09"); 21526 assert(ios.width() == 0); 21527 } 21528 ios.width(25); 21529 left(ios); 21530 { 21531 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21532 std::string ex(str, iter.base()); 21533 assert(ex == "1.2e+09******************"); 21534 assert(ios.width() == 0); 21535 } 21536 ios.width(25); 21537 right(ios); 21538 { 21539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21540 std::string ex(str, iter.base()); 21541 assert(ex == "******************1.2e+09"); 21542 assert(ios.width() == 0); 21543 } 21544 ios.width(25); 21545 internal(ios); 21546 { 21547 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21548 std::string ex(str, iter.base()); 21549 assert(ex == "******************1.2e+09"); 21550 assert(ios.width() == 0); 21551 } 21552 } 21553 ios.imbue(lg); 21554 { 21555 ios.width(0); 21556 { 21557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21558 std::string ex(str, iter.base()); 21559 assert(ex == "1;2e+09"); 21560 assert(ios.width() == 0); 21561 } 21562 ios.width(25); 21563 left(ios); 21564 { 21565 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21566 std::string ex(str, iter.base()); 21567 assert(ex == "1;2e+09******************"); 21568 assert(ios.width() == 0); 21569 } 21570 ios.width(25); 21571 right(ios); 21572 { 21573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21574 std::string ex(str, iter.base()); 21575 assert(ex == "******************1;2e+09"); 21576 assert(ios.width() == 0); 21577 } 21578 ios.width(25); 21579 internal(ios); 21580 { 21581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21582 std::string ex(str, iter.base()); 21583 assert(ex == "******************1;2e+09"); 21584 assert(ios.width() == 0); 21585 } 21586 } 21587 } 21588 } 21589 showpos(ios); 21590 { 21591 noshowpoint(ios); 21592 { 21593 ios.imbue(lc); 21594 { 21595 ios.width(0); 21596 { 21597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21598 std::string ex(str, iter.base()); 21599 assert(ex == "+1.2e+09"); 21600 assert(ios.width() == 0); 21601 } 21602 ios.width(25); 21603 left(ios); 21604 { 21605 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21606 std::string ex(str, iter.base()); 21607 assert(ex == "+1.2e+09*****************"); 21608 assert(ios.width() == 0); 21609 } 21610 ios.width(25); 21611 right(ios); 21612 { 21613 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21614 std::string ex(str, iter.base()); 21615 assert(ex == "*****************+1.2e+09"); 21616 assert(ios.width() == 0); 21617 } 21618 ios.width(25); 21619 internal(ios); 21620 { 21621 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21622 std::string ex(str, iter.base()); 21623 assert(ex == "+*****************1.2e+09"); 21624 assert(ios.width() == 0); 21625 } 21626 } 21627 ios.imbue(lg); 21628 { 21629 ios.width(0); 21630 { 21631 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21632 std::string ex(str, iter.base()); 21633 assert(ex == "+1;2e+09"); 21634 assert(ios.width() == 0); 21635 } 21636 ios.width(25); 21637 left(ios); 21638 { 21639 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21640 std::string ex(str, iter.base()); 21641 assert(ex == "+1;2e+09*****************"); 21642 assert(ios.width() == 0); 21643 } 21644 ios.width(25); 21645 right(ios); 21646 { 21647 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21648 std::string ex(str, iter.base()); 21649 assert(ex == "*****************+1;2e+09"); 21650 assert(ios.width() == 0); 21651 } 21652 ios.width(25); 21653 internal(ios); 21654 { 21655 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21656 std::string ex(str, iter.base()); 21657 assert(ex == "+*****************1;2e+09"); 21658 assert(ios.width() == 0); 21659 } 21660 } 21661 } 21662 showpoint(ios); 21663 { 21664 ios.imbue(lc); 21665 { 21666 ios.width(0); 21667 { 21668 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21669 std::string ex(str, iter.base()); 21670 assert(ex == "+1.2e+09"); 21671 assert(ios.width() == 0); 21672 } 21673 ios.width(25); 21674 left(ios); 21675 { 21676 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21677 std::string ex(str, iter.base()); 21678 assert(ex == "+1.2e+09*****************"); 21679 assert(ios.width() == 0); 21680 } 21681 ios.width(25); 21682 right(ios); 21683 { 21684 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21685 std::string ex(str, iter.base()); 21686 assert(ex == "*****************+1.2e+09"); 21687 assert(ios.width() == 0); 21688 } 21689 ios.width(25); 21690 internal(ios); 21691 { 21692 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21693 std::string ex(str, iter.base()); 21694 assert(ex == "+*****************1.2e+09"); 21695 assert(ios.width() == 0); 21696 } 21697 } 21698 ios.imbue(lg); 21699 { 21700 ios.width(0); 21701 { 21702 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21703 std::string ex(str, iter.base()); 21704 assert(ex == "+1;2e+09"); 21705 assert(ios.width() == 0); 21706 } 21707 ios.width(25); 21708 left(ios); 21709 { 21710 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21711 std::string ex(str, iter.base()); 21712 assert(ex == "+1;2e+09*****************"); 21713 assert(ios.width() == 0); 21714 } 21715 ios.width(25); 21716 right(ios); 21717 { 21718 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21719 std::string ex(str, iter.base()); 21720 assert(ex == "*****************+1;2e+09"); 21721 assert(ios.width() == 0); 21722 } 21723 ios.width(25); 21724 internal(ios); 21725 { 21726 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21727 std::string ex(str, iter.base()); 21728 assert(ex == "+*****************1;2e+09"); 21729 assert(ios.width() == 0); 21730 } 21731 } 21732 } 21733 } 21734 } 21735 uppercase(ios); 21736 { 21737 noshowpos(ios); 21738 { 21739 noshowpoint(ios); 21740 { 21741 ios.imbue(lc); 21742 { 21743 ios.width(0); 21744 { 21745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21746 std::string ex(str, iter.base()); 21747 assert(ex == "1.2E+09"); 21748 assert(ios.width() == 0); 21749 } 21750 ios.width(25); 21751 left(ios); 21752 { 21753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21754 std::string ex(str, iter.base()); 21755 assert(ex == "1.2E+09******************"); 21756 assert(ios.width() == 0); 21757 } 21758 ios.width(25); 21759 right(ios); 21760 { 21761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21762 std::string ex(str, iter.base()); 21763 assert(ex == "******************1.2E+09"); 21764 assert(ios.width() == 0); 21765 } 21766 ios.width(25); 21767 internal(ios); 21768 { 21769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21770 std::string ex(str, iter.base()); 21771 assert(ex == "******************1.2E+09"); 21772 assert(ios.width() == 0); 21773 } 21774 } 21775 ios.imbue(lg); 21776 { 21777 ios.width(0); 21778 { 21779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21780 std::string ex(str, iter.base()); 21781 assert(ex == "1;2E+09"); 21782 assert(ios.width() == 0); 21783 } 21784 ios.width(25); 21785 left(ios); 21786 { 21787 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21788 std::string ex(str, iter.base()); 21789 assert(ex == "1;2E+09******************"); 21790 assert(ios.width() == 0); 21791 } 21792 ios.width(25); 21793 right(ios); 21794 { 21795 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21796 std::string ex(str, iter.base()); 21797 assert(ex == "******************1;2E+09"); 21798 assert(ios.width() == 0); 21799 } 21800 ios.width(25); 21801 internal(ios); 21802 { 21803 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21804 std::string ex(str, iter.base()); 21805 assert(ex == "******************1;2E+09"); 21806 assert(ios.width() == 0); 21807 } 21808 } 21809 } 21810 showpoint(ios); 21811 { 21812 ios.imbue(lc); 21813 { 21814 ios.width(0); 21815 { 21816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21817 std::string ex(str, iter.base()); 21818 assert(ex == "1.2E+09"); 21819 assert(ios.width() == 0); 21820 } 21821 ios.width(25); 21822 left(ios); 21823 { 21824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21825 std::string ex(str, iter.base()); 21826 assert(ex == "1.2E+09******************"); 21827 assert(ios.width() == 0); 21828 } 21829 ios.width(25); 21830 right(ios); 21831 { 21832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21833 std::string ex(str, iter.base()); 21834 assert(ex == "******************1.2E+09"); 21835 assert(ios.width() == 0); 21836 } 21837 ios.width(25); 21838 internal(ios); 21839 { 21840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21841 std::string ex(str, iter.base()); 21842 assert(ex == "******************1.2E+09"); 21843 assert(ios.width() == 0); 21844 } 21845 } 21846 ios.imbue(lg); 21847 { 21848 ios.width(0); 21849 { 21850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21851 std::string ex(str, iter.base()); 21852 assert(ex == "1;2E+09"); 21853 assert(ios.width() == 0); 21854 } 21855 ios.width(25); 21856 left(ios); 21857 { 21858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21859 std::string ex(str, iter.base()); 21860 assert(ex == "1;2E+09******************"); 21861 assert(ios.width() == 0); 21862 } 21863 ios.width(25); 21864 right(ios); 21865 { 21866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21867 std::string ex(str, iter.base()); 21868 assert(ex == "******************1;2E+09"); 21869 assert(ios.width() == 0); 21870 } 21871 ios.width(25); 21872 internal(ios); 21873 { 21874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21875 std::string ex(str, iter.base()); 21876 assert(ex == "******************1;2E+09"); 21877 assert(ios.width() == 0); 21878 } 21879 } 21880 } 21881 } 21882 showpos(ios); 21883 { 21884 noshowpoint(ios); 21885 { 21886 ios.imbue(lc); 21887 { 21888 ios.width(0); 21889 { 21890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21891 std::string ex(str, iter.base()); 21892 assert(ex == "+1.2E+09"); 21893 assert(ios.width() == 0); 21894 } 21895 ios.width(25); 21896 left(ios); 21897 { 21898 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21899 std::string ex(str, iter.base()); 21900 assert(ex == "+1.2E+09*****************"); 21901 assert(ios.width() == 0); 21902 } 21903 ios.width(25); 21904 right(ios); 21905 { 21906 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21907 std::string ex(str, iter.base()); 21908 assert(ex == "*****************+1.2E+09"); 21909 assert(ios.width() == 0); 21910 } 21911 ios.width(25); 21912 internal(ios); 21913 { 21914 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21915 std::string ex(str, iter.base()); 21916 assert(ex == "+*****************1.2E+09"); 21917 assert(ios.width() == 0); 21918 } 21919 } 21920 ios.imbue(lg); 21921 { 21922 ios.width(0); 21923 { 21924 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21925 std::string ex(str, iter.base()); 21926 assert(ex == "+1;2E+09"); 21927 assert(ios.width() == 0); 21928 } 21929 ios.width(25); 21930 left(ios); 21931 { 21932 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21933 std::string ex(str, iter.base()); 21934 assert(ex == "+1;2E+09*****************"); 21935 assert(ios.width() == 0); 21936 } 21937 ios.width(25); 21938 right(ios); 21939 { 21940 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21941 std::string ex(str, iter.base()); 21942 assert(ex == "*****************+1;2E+09"); 21943 assert(ios.width() == 0); 21944 } 21945 ios.width(25); 21946 internal(ios); 21947 { 21948 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21949 std::string ex(str, iter.base()); 21950 assert(ex == "+*****************1;2E+09"); 21951 assert(ios.width() == 0); 21952 } 21953 } 21954 } 21955 showpoint(ios); 21956 { 21957 ios.imbue(lc); 21958 { 21959 ios.width(0); 21960 { 21961 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21962 std::string ex(str, iter.base()); 21963 assert(ex == "+1.2E+09"); 21964 assert(ios.width() == 0); 21965 } 21966 ios.width(25); 21967 left(ios); 21968 { 21969 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21970 std::string ex(str, iter.base()); 21971 assert(ex == "+1.2E+09*****************"); 21972 assert(ios.width() == 0); 21973 } 21974 ios.width(25); 21975 right(ios); 21976 { 21977 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21978 std::string ex(str, iter.base()); 21979 assert(ex == "*****************+1.2E+09"); 21980 assert(ios.width() == 0); 21981 } 21982 ios.width(25); 21983 internal(ios); 21984 { 21985 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21986 std::string ex(str, iter.base()); 21987 assert(ex == "+*****************1.2E+09"); 21988 assert(ios.width() == 0); 21989 } 21990 } 21991 ios.imbue(lg); 21992 { 21993 ios.width(0); 21994 { 21995 iter = f.put(output_iterator<char*>(str), ios, '*', v); 21996 std::string ex(str, iter.base()); 21997 assert(ex == "+1;2E+09"); 21998 assert(ios.width() == 0); 21999 } 22000 ios.width(25); 22001 left(ios); 22002 { 22003 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22004 std::string ex(str, iter.base()); 22005 assert(ex == "+1;2E+09*****************"); 22006 assert(ios.width() == 0); 22007 } 22008 ios.width(25); 22009 right(ios); 22010 { 22011 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22012 std::string ex(str, iter.base()); 22013 assert(ex == "*****************+1;2E+09"); 22014 assert(ios.width() == 0); 22015 } 22016 ios.width(25); 22017 internal(ios); 22018 { 22019 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22020 std::string ex(str, iter.base()); 22021 assert(ex == "+*****************1;2E+09"); 22022 assert(ios.width() == 0); 22023 } 22024 } 22025 } 22026 } 22027 } 22028 } 22029 ios.precision(6); 22030 { 22031 } 22032 ios.precision(16); 22033 { 22034 } 22035 ios.precision(60); 22036 { 22037 nouppercase(ios); 22038 { 22039 noshowpos(ios); 22040 { 22041 noshowpoint(ios); 22042 { 22043 ios.imbue(lc); 22044 { 22045 ios.width(0); 22046 { 22047 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22048 std::string ex(str, iter.base()); 22049 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22050 assert(ios.width() == 0); 22051 } 22052 ios.width(25); 22053 left(ios); 22054 { 22055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22056 std::string ex(str, iter.base()); 22057 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22058 assert(ios.width() == 0); 22059 } 22060 ios.width(25); 22061 right(ios); 22062 { 22063 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22064 std::string ex(str, iter.base()); 22065 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22066 assert(ios.width() == 0); 22067 } 22068 ios.width(25); 22069 internal(ios); 22070 { 22071 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22072 std::string ex(str, iter.base()); 22073 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22074 assert(ios.width() == 0); 22075 } 22076 } 22077 ios.imbue(lg); 22078 { 22079 ios.width(0); 22080 { 22081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22082 std::string ex(str, iter.base()); 22083 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22084 assert(ios.width() == 0); 22085 } 22086 ios.width(25); 22087 left(ios); 22088 { 22089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22090 std::string ex(str, iter.base()); 22091 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22092 assert(ios.width() == 0); 22093 } 22094 ios.width(25); 22095 right(ios); 22096 { 22097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22098 std::string ex(str, iter.base()); 22099 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22100 assert(ios.width() == 0); 22101 } 22102 ios.width(25); 22103 internal(ios); 22104 { 22105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22106 std::string ex(str, iter.base()); 22107 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22108 assert(ios.width() == 0); 22109 } 22110 } 22111 } 22112 showpoint(ios); 22113 { 22114 ios.imbue(lc); 22115 { 22116 ios.width(0); 22117 { 22118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22119 std::string ex(str, iter.base()); 22120 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22121 assert(ios.width() == 0); 22122 } 22123 ios.width(25); 22124 left(ios); 22125 { 22126 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22127 std::string ex(str, iter.base()); 22128 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22129 assert(ios.width() == 0); 22130 } 22131 ios.width(25); 22132 right(ios); 22133 { 22134 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22135 std::string ex(str, iter.base()); 22136 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22137 assert(ios.width() == 0); 22138 } 22139 ios.width(25); 22140 internal(ios); 22141 { 22142 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22143 std::string ex(str, iter.base()); 22144 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 22145 assert(ios.width() == 0); 22146 } 22147 } 22148 ios.imbue(lg); 22149 { 22150 ios.width(0); 22151 { 22152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22153 std::string ex(str, iter.base()); 22154 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22155 assert(ios.width() == 0); 22156 } 22157 ios.width(25); 22158 left(ios); 22159 { 22160 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22161 std::string ex(str, iter.base()); 22162 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22163 assert(ios.width() == 0); 22164 } 22165 ios.width(25); 22166 right(ios); 22167 { 22168 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22169 std::string ex(str, iter.base()); 22170 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22171 assert(ios.width() == 0); 22172 } 22173 ios.width(25); 22174 internal(ios); 22175 { 22176 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22177 std::string ex(str, iter.base()); 22178 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 22179 assert(ios.width() == 0); 22180 } 22181 } 22182 } 22183 } 22184 showpos(ios); 22185 { 22186 noshowpoint(ios); 22187 { 22188 ios.imbue(lc); 22189 { 22190 ios.width(0); 22191 { 22192 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22193 std::string ex(str, iter.base()); 22194 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22195 assert(ios.width() == 0); 22196 } 22197 ios.width(25); 22198 left(ios); 22199 { 22200 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22201 std::string ex(str, iter.base()); 22202 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22203 assert(ios.width() == 0); 22204 } 22205 ios.width(25); 22206 right(ios); 22207 { 22208 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22209 std::string ex(str, iter.base()); 22210 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22211 assert(ios.width() == 0); 22212 } 22213 ios.width(25); 22214 internal(ios); 22215 { 22216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22217 std::string ex(str, iter.base()); 22218 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22219 assert(ios.width() == 0); 22220 } 22221 } 22222 ios.imbue(lg); 22223 { 22224 ios.width(0); 22225 { 22226 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22227 std::string ex(str, iter.base()); 22228 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22229 assert(ios.width() == 0); 22230 } 22231 ios.width(25); 22232 left(ios); 22233 { 22234 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22235 std::string ex(str, iter.base()); 22236 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22237 assert(ios.width() == 0); 22238 } 22239 ios.width(25); 22240 right(ios); 22241 { 22242 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22243 std::string ex(str, iter.base()); 22244 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22245 assert(ios.width() == 0); 22246 } 22247 ios.width(25); 22248 internal(ios); 22249 { 22250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22251 std::string ex(str, iter.base()); 22252 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22253 assert(ios.width() == 0); 22254 } 22255 } 22256 } 22257 showpoint(ios); 22258 { 22259 ios.imbue(lc); 22260 { 22261 ios.width(0); 22262 { 22263 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22264 std::string ex(str, iter.base()); 22265 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22266 assert(ios.width() == 0); 22267 } 22268 ios.width(25); 22269 left(ios); 22270 { 22271 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22272 std::string ex(str, iter.base()); 22273 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22274 assert(ios.width() == 0); 22275 } 22276 ios.width(25); 22277 right(ios); 22278 { 22279 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22280 std::string ex(str, iter.base()); 22281 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22282 assert(ios.width() == 0); 22283 } 22284 ios.width(25); 22285 internal(ios); 22286 { 22287 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22288 std::string ex(str, iter.base()); 22289 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 22290 assert(ios.width() == 0); 22291 } 22292 } 22293 ios.imbue(lg); 22294 { 22295 ios.width(0); 22296 { 22297 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22298 std::string ex(str, iter.base()); 22299 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22300 assert(ios.width() == 0); 22301 } 22302 ios.width(25); 22303 left(ios); 22304 { 22305 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22306 std::string ex(str, iter.base()); 22307 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22308 assert(ios.width() == 0); 22309 } 22310 ios.width(25); 22311 right(ios); 22312 { 22313 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22314 std::string ex(str, iter.base()); 22315 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22316 assert(ios.width() == 0); 22317 } 22318 ios.width(25); 22319 internal(ios); 22320 { 22321 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22322 std::string ex(str, iter.base()); 22323 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 22324 assert(ios.width() == 0); 22325 } 22326 } 22327 } 22328 } 22329 } 22330 uppercase(ios); 22331 { 22332 noshowpos(ios); 22333 { 22334 noshowpoint(ios); 22335 { 22336 ios.imbue(lc); 22337 { 22338 ios.width(0); 22339 { 22340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22341 std::string ex(str, iter.base()); 22342 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22343 assert(ios.width() == 0); 22344 } 22345 ios.width(25); 22346 left(ios); 22347 { 22348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22349 std::string ex(str, iter.base()); 22350 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22351 assert(ios.width() == 0); 22352 } 22353 ios.width(25); 22354 right(ios); 22355 { 22356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22357 std::string ex(str, iter.base()); 22358 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22359 assert(ios.width() == 0); 22360 } 22361 ios.width(25); 22362 internal(ios); 22363 { 22364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22365 std::string ex(str, iter.base()); 22366 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22367 assert(ios.width() == 0); 22368 } 22369 } 22370 ios.imbue(lg); 22371 { 22372 ios.width(0); 22373 { 22374 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22375 std::string ex(str, iter.base()); 22376 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22377 assert(ios.width() == 0); 22378 } 22379 ios.width(25); 22380 left(ios); 22381 { 22382 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22383 std::string ex(str, iter.base()); 22384 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22385 assert(ios.width() == 0); 22386 } 22387 ios.width(25); 22388 right(ios); 22389 { 22390 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22391 std::string ex(str, iter.base()); 22392 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22393 assert(ios.width() == 0); 22394 } 22395 ios.width(25); 22396 internal(ios); 22397 { 22398 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22399 std::string ex(str, iter.base()); 22400 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22401 assert(ios.width() == 0); 22402 } 22403 } 22404 } 22405 showpoint(ios); 22406 { 22407 ios.imbue(lc); 22408 { 22409 ios.width(0); 22410 { 22411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22412 std::string ex(str, iter.base()); 22413 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22414 assert(ios.width() == 0); 22415 } 22416 ios.width(25); 22417 left(ios); 22418 { 22419 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22420 std::string ex(str, iter.base()); 22421 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22422 assert(ios.width() == 0); 22423 } 22424 ios.width(25); 22425 right(ios); 22426 { 22427 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22428 std::string ex(str, iter.base()); 22429 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22430 assert(ios.width() == 0); 22431 } 22432 ios.width(25); 22433 internal(ios); 22434 { 22435 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22436 std::string ex(str, iter.base()); 22437 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 22438 assert(ios.width() == 0); 22439 } 22440 } 22441 ios.imbue(lg); 22442 { 22443 ios.width(0); 22444 { 22445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22446 std::string ex(str, iter.base()); 22447 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22448 assert(ios.width() == 0); 22449 } 22450 ios.width(25); 22451 left(ios); 22452 { 22453 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22454 std::string ex(str, iter.base()); 22455 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22456 assert(ios.width() == 0); 22457 } 22458 ios.width(25); 22459 right(ios); 22460 { 22461 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22462 std::string ex(str, iter.base()); 22463 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22464 assert(ios.width() == 0); 22465 } 22466 ios.width(25); 22467 internal(ios); 22468 { 22469 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22470 std::string ex(str, iter.base()); 22471 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 22472 assert(ios.width() == 0); 22473 } 22474 } 22475 } 22476 } 22477 showpos(ios); 22478 { 22479 noshowpoint(ios); 22480 { 22481 ios.imbue(lc); 22482 { 22483 ios.width(0); 22484 { 22485 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22486 std::string ex(str, iter.base()); 22487 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22488 assert(ios.width() == 0); 22489 } 22490 ios.width(25); 22491 left(ios); 22492 { 22493 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22494 std::string ex(str, iter.base()); 22495 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22496 assert(ios.width() == 0); 22497 } 22498 ios.width(25); 22499 right(ios); 22500 { 22501 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22502 std::string ex(str, iter.base()); 22503 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22504 assert(ios.width() == 0); 22505 } 22506 ios.width(25); 22507 internal(ios); 22508 { 22509 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22510 std::string ex(str, iter.base()); 22511 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22512 assert(ios.width() == 0); 22513 } 22514 } 22515 ios.imbue(lg); 22516 { 22517 ios.width(0); 22518 { 22519 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22520 std::string ex(str, iter.base()); 22521 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22522 assert(ios.width() == 0); 22523 } 22524 ios.width(25); 22525 left(ios); 22526 { 22527 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22528 std::string ex(str, iter.base()); 22529 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22530 assert(ios.width() == 0); 22531 } 22532 ios.width(25); 22533 right(ios); 22534 { 22535 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22536 std::string ex(str, iter.base()); 22537 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22538 assert(ios.width() == 0); 22539 } 22540 ios.width(25); 22541 internal(ios); 22542 { 22543 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22544 std::string ex(str, iter.base()); 22545 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22546 assert(ios.width() == 0); 22547 } 22548 } 22549 } 22550 showpoint(ios); 22551 { 22552 ios.imbue(lc); 22553 { 22554 ios.width(0); 22555 { 22556 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22557 std::string ex(str, iter.base()); 22558 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22559 assert(ios.width() == 0); 22560 } 22561 ios.width(25); 22562 left(ios); 22563 { 22564 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22565 std::string ex(str, iter.base()); 22566 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22567 assert(ios.width() == 0); 22568 } 22569 ios.width(25); 22570 right(ios); 22571 { 22572 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22573 std::string ex(str, iter.base()); 22574 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22575 assert(ios.width() == 0); 22576 } 22577 ios.width(25); 22578 internal(ios); 22579 { 22580 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22581 std::string ex(str, iter.base()); 22582 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 22583 assert(ios.width() == 0); 22584 } 22585 } 22586 ios.imbue(lg); 22587 { 22588 ios.width(0); 22589 { 22590 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22591 std::string ex(str, iter.base()); 22592 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22593 assert(ios.width() == 0); 22594 } 22595 ios.width(25); 22596 left(ios); 22597 { 22598 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22599 std::string ex(str, iter.base()); 22600 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22601 assert(ios.width() == 0); 22602 } 22603 ios.width(25); 22604 right(ios); 22605 { 22606 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22607 std::string ex(str, iter.base()); 22608 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22609 assert(ios.width() == 0); 22610 } 22611 ios.width(25); 22612 internal(ios); 22613 { 22614 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22615 std::string ex(str, iter.base()); 22616 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 22617 assert(ios.width() == 0); 22618 } 22619 } 22620 } 22621 } 22622 } 22623 } 22624 } 22625 } 22626 } 22627 22628 void test11() 22629 { 22630 char str[200]; 22631 output_iterator<char*> iter; 22632 std::locale lc = std::locale::classic(); 22633 std::locale lg(lc, new my_numpunct); 22634 const my_facet f(1); 22635 { 22636 long double v = -0.; 22637 std::ios ios(0); 22638 hexfloat(ios); 22639 // %a 22640 { 22641 ios.precision(0); 22642 { 22643 nouppercase(ios); 22644 { 22645 noshowpos(ios); 22646 { 22647 noshowpoint(ios); 22648 { 22649 ios.imbue(lc); 22650 { 22651 ios.width(0); 22652 { 22653 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22654 std::string ex(str, iter.base()); 22655 assert(ex == "-0x0p+0"); 22656 assert(ios.width() == 0); 22657 } 22658 ios.width(25); 22659 left(ios); 22660 { 22661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22662 std::string ex(str, iter.base()); 22663 assert(ex == "-0x0p+0******************"); 22664 assert(ios.width() == 0); 22665 } 22666 ios.width(25); 22667 right(ios); 22668 { 22669 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22670 std::string ex(str, iter.base()); 22671 assert(ex == "******************-0x0p+0"); 22672 assert(ios.width() == 0); 22673 } 22674 ios.width(25); 22675 internal(ios); 22676 { 22677 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22678 std::string ex(str, iter.base()); 22679 assert(ex == "-******************0x0p+0"); 22680 assert(ios.width() == 0); 22681 } 22682 } 22683 ios.imbue(lg); 22684 { 22685 ios.width(0); 22686 { 22687 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22688 std::string ex(str, iter.base()); 22689 assert(ex == "-0x0p+0"); 22690 assert(ios.width() == 0); 22691 } 22692 ios.width(25); 22693 left(ios); 22694 { 22695 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22696 std::string ex(str, iter.base()); 22697 assert(ex == "-0x0p+0******************"); 22698 assert(ios.width() == 0); 22699 } 22700 ios.width(25); 22701 right(ios); 22702 { 22703 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22704 std::string ex(str, iter.base()); 22705 assert(ex == "******************-0x0p+0"); 22706 assert(ios.width() == 0); 22707 } 22708 ios.width(25); 22709 internal(ios); 22710 { 22711 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22712 std::string ex(str, iter.base()); 22713 assert(ex == "-******************0x0p+0"); 22714 assert(ios.width() == 0); 22715 } 22716 } 22717 } 22718 showpoint(ios); 22719 { 22720 ios.imbue(lc); 22721 { 22722 ios.width(0); 22723 { 22724 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22725 std::string ex(str, iter.base()); 22726 assert(ex == "-0x0.p+0"); 22727 assert(ios.width() == 0); 22728 } 22729 ios.width(25); 22730 left(ios); 22731 { 22732 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22733 std::string ex(str, iter.base()); 22734 assert(ex == "-0x0.p+0*****************"); 22735 assert(ios.width() == 0); 22736 } 22737 ios.width(25); 22738 right(ios); 22739 { 22740 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22741 std::string ex(str, iter.base()); 22742 assert(ex == "*****************-0x0.p+0"); 22743 assert(ios.width() == 0); 22744 } 22745 ios.width(25); 22746 internal(ios); 22747 { 22748 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22749 std::string ex(str, iter.base()); 22750 assert(ex == "-*****************0x0.p+0"); 22751 assert(ios.width() == 0); 22752 } 22753 } 22754 ios.imbue(lg); 22755 { 22756 ios.width(0); 22757 { 22758 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22759 std::string ex(str, iter.base()); 22760 assert(ex == "-0x0;p+0"); 22761 assert(ios.width() == 0); 22762 } 22763 ios.width(25); 22764 left(ios); 22765 { 22766 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22767 std::string ex(str, iter.base()); 22768 assert(ex == "-0x0;p+0*****************"); 22769 assert(ios.width() == 0); 22770 } 22771 ios.width(25); 22772 right(ios); 22773 { 22774 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22775 std::string ex(str, iter.base()); 22776 assert(ex == "*****************-0x0;p+0"); 22777 assert(ios.width() == 0); 22778 } 22779 ios.width(25); 22780 internal(ios); 22781 { 22782 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22783 std::string ex(str, iter.base()); 22784 assert(ex == "-*****************0x0;p+0"); 22785 assert(ios.width() == 0); 22786 } 22787 } 22788 } 22789 } 22790 showpos(ios); 22791 { 22792 noshowpoint(ios); 22793 { 22794 ios.imbue(lc); 22795 { 22796 ios.width(0); 22797 { 22798 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22799 std::string ex(str, iter.base()); 22800 assert(ex == "-0x0p+0"); 22801 assert(ios.width() == 0); 22802 } 22803 ios.width(25); 22804 left(ios); 22805 { 22806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22807 std::string ex(str, iter.base()); 22808 assert(ex == "-0x0p+0******************"); 22809 assert(ios.width() == 0); 22810 } 22811 ios.width(25); 22812 right(ios); 22813 { 22814 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22815 std::string ex(str, iter.base()); 22816 assert(ex == "******************-0x0p+0"); 22817 assert(ios.width() == 0); 22818 } 22819 ios.width(25); 22820 internal(ios); 22821 { 22822 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22823 std::string ex(str, iter.base()); 22824 assert(ex == "-******************0x0p+0"); 22825 assert(ios.width() == 0); 22826 } 22827 } 22828 ios.imbue(lg); 22829 { 22830 ios.width(0); 22831 { 22832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22833 std::string ex(str, iter.base()); 22834 assert(ex == "-0x0p+0"); 22835 assert(ios.width() == 0); 22836 } 22837 ios.width(25); 22838 left(ios); 22839 { 22840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22841 std::string ex(str, iter.base()); 22842 assert(ex == "-0x0p+0******************"); 22843 assert(ios.width() == 0); 22844 } 22845 ios.width(25); 22846 right(ios); 22847 { 22848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22849 std::string ex(str, iter.base()); 22850 assert(ex == "******************-0x0p+0"); 22851 assert(ios.width() == 0); 22852 } 22853 ios.width(25); 22854 internal(ios); 22855 { 22856 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22857 std::string ex(str, iter.base()); 22858 assert(ex == "-******************0x0p+0"); 22859 assert(ios.width() == 0); 22860 } 22861 } 22862 } 22863 showpoint(ios); 22864 { 22865 ios.imbue(lc); 22866 { 22867 ios.width(0); 22868 { 22869 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22870 std::string ex(str, iter.base()); 22871 assert(ex == "-0x0.p+0"); 22872 assert(ios.width() == 0); 22873 } 22874 ios.width(25); 22875 left(ios); 22876 { 22877 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22878 std::string ex(str, iter.base()); 22879 assert(ex == "-0x0.p+0*****************"); 22880 assert(ios.width() == 0); 22881 } 22882 ios.width(25); 22883 right(ios); 22884 { 22885 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22886 std::string ex(str, iter.base()); 22887 assert(ex == "*****************-0x0.p+0"); 22888 assert(ios.width() == 0); 22889 } 22890 ios.width(25); 22891 internal(ios); 22892 { 22893 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22894 std::string ex(str, iter.base()); 22895 assert(ex == "-*****************0x0.p+0"); 22896 assert(ios.width() == 0); 22897 } 22898 } 22899 ios.imbue(lg); 22900 { 22901 ios.width(0); 22902 { 22903 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22904 std::string ex(str, iter.base()); 22905 assert(ex == "-0x0;p+0"); 22906 assert(ios.width() == 0); 22907 } 22908 ios.width(25); 22909 left(ios); 22910 { 22911 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22912 std::string ex(str, iter.base()); 22913 assert(ex == "-0x0;p+0*****************"); 22914 assert(ios.width() == 0); 22915 } 22916 ios.width(25); 22917 right(ios); 22918 { 22919 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22920 std::string ex(str, iter.base()); 22921 assert(ex == "*****************-0x0;p+0"); 22922 assert(ios.width() == 0); 22923 } 22924 ios.width(25); 22925 internal(ios); 22926 { 22927 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22928 std::string ex(str, iter.base()); 22929 assert(ex == "-*****************0x0;p+0"); 22930 assert(ios.width() == 0); 22931 } 22932 } 22933 } 22934 } 22935 } 22936 uppercase(ios); 22937 { 22938 noshowpos(ios); 22939 { 22940 noshowpoint(ios); 22941 { 22942 ios.imbue(lc); 22943 { 22944 ios.width(0); 22945 { 22946 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22947 std::string ex(str, iter.base()); 22948 assert(ex == "-0X0P+0"); 22949 assert(ios.width() == 0); 22950 } 22951 ios.width(25); 22952 left(ios); 22953 { 22954 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22955 std::string ex(str, iter.base()); 22956 assert(ex == "-0X0P+0******************"); 22957 assert(ios.width() == 0); 22958 } 22959 ios.width(25); 22960 right(ios); 22961 { 22962 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22963 std::string ex(str, iter.base()); 22964 assert(ex == "******************-0X0P+0"); 22965 assert(ios.width() == 0); 22966 } 22967 ios.width(25); 22968 internal(ios); 22969 { 22970 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22971 std::string ex(str, iter.base()); 22972 assert(ex == "-******************0X0P+0"); 22973 assert(ios.width() == 0); 22974 } 22975 } 22976 ios.imbue(lg); 22977 { 22978 ios.width(0); 22979 { 22980 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22981 std::string ex(str, iter.base()); 22982 assert(ex == "-0X0P+0"); 22983 assert(ios.width() == 0); 22984 } 22985 ios.width(25); 22986 left(ios); 22987 { 22988 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22989 std::string ex(str, iter.base()); 22990 assert(ex == "-0X0P+0******************"); 22991 assert(ios.width() == 0); 22992 } 22993 ios.width(25); 22994 right(ios); 22995 { 22996 iter = f.put(output_iterator<char*>(str), ios, '*', v); 22997 std::string ex(str, iter.base()); 22998 assert(ex == "******************-0X0P+0"); 22999 assert(ios.width() == 0); 23000 } 23001 ios.width(25); 23002 internal(ios); 23003 { 23004 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23005 std::string ex(str, iter.base()); 23006 assert(ex == "-******************0X0P+0"); 23007 assert(ios.width() == 0); 23008 } 23009 } 23010 } 23011 showpoint(ios); 23012 { 23013 ios.imbue(lc); 23014 { 23015 ios.width(0); 23016 { 23017 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23018 std::string ex(str, iter.base()); 23019 assert(ex == "-0X0.P+0"); 23020 assert(ios.width() == 0); 23021 } 23022 ios.width(25); 23023 left(ios); 23024 { 23025 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23026 std::string ex(str, iter.base()); 23027 assert(ex == "-0X0.P+0*****************"); 23028 assert(ios.width() == 0); 23029 } 23030 ios.width(25); 23031 right(ios); 23032 { 23033 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23034 std::string ex(str, iter.base()); 23035 assert(ex == "*****************-0X0.P+0"); 23036 assert(ios.width() == 0); 23037 } 23038 ios.width(25); 23039 internal(ios); 23040 { 23041 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23042 std::string ex(str, iter.base()); 23043 assert(ex == "-*****************0X0.P+0"); 23044 assert(ios.width() == 0); 23045 } 23046 } 23047 ios.imbue(lg); 23048 { 23049 ios.width(0); 23050 { 23051 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23052 std::string ex(str, iter.base()); 23053 assert(ex == "-0X0;P+0"); 23054 assert(ios.width() == 0); 23055 } 23056 ios.width(25); 23057 left(ios); 23058 { 23059 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23060 std::string ex(str, iter.base()); 23061 assert(ex == "-0X0;P+0*****************"); 23062 assert(ios.width() == 0); 23063 } 23064 ios.width(25); 23065 right(ios); 23066 { 23067 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23068 std::string ex(str, iter.base()); 23069 assert(ex == "*****************-0X0;P+0"); 23070 assert(ios.width() == 0); 23071 } 23072 ios.width(25); 23073 internal(ios); 23074 { 23075 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23076 std::string ex(str, iter.base()); 23077 assert(ex == "-*****************0X0;P+0"); 23078 assert(ios.width() == 0); 23079 } 23080 } 23081 } 23082 } 23083 showpos(ios); 23084 { 23085 noshowpoint(ios); 23086 { 23087 ios.imbue(lc); 23088 { 23089 ios.width(0); 23090 { 23091 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23092 std::string ex(str, iter.base()); 23093 assert(ex == "-0X0P+0"); 23094 assert(ios.width() == 0); 23095 } 23096 ios.width(25); 23097 left(ios); 23098 { 23099 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23100 std::string ex(str, iter.base()); 23101 assert(ex == "-0X0P+0******************"); 23102 assert(ios.width() == 0); 23103 } 23104 ios.width(25); 23105 right(ios); 23106 { 23107 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23108 std::string ex(str, iter.base()); 23109 assert(ex == "******************-0X0P+0"); 23110 assert(ios.width() == 0); 23111 } 23112 ios.width(25); 23113 internal(ios); 23114 { 23115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23116 std::string ex(str, iter.base()); 23117 assert(ex == "-******************0X0P+0"); 23118 assert(ios.width() == 0); 23119 } 23120 } 23121 ios.imbue(lg); 23122 { 23123 ios.width(0); 23124 { 23125 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23126 std::string ex(str, iter.base()); 23127 assert(ex == "-0X0P+0"); 23128 assert(ios.width() == 0); 23129 } 23130 ios.width(25); 23131 left(ios); 23132 { 23133 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23134 std::string ex(str, iter.base()); 23135 assert(ex == "-0X0P+0******************"); 23136 assert(ios.width() == 0); 23137 } 23138 ios.width(25); 23139 right(ios); 23140 { 23141 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23142 std::string ex(str, iter.base()); 23143 assert(ex == "******************-0X0P+0"); 23144 assert(ios.width() == 0); 23145 } 23146 ios.width(25); 23147 internal(ios); 23148 { 23149 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23150 std::string ex(str, iter.base()); 23151 assert(ex == "-******************0X0P+0"); 23152 assert(ios.width() == 0); 23153 } 23154 } 23155 } 23156 showpoint(ios); 23157 { 23158 ios.imbue(lc); 23159 { 23160 ios.width(0); 23161 { 23162 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23163 std::string ex(str, iter.base()); 23164 assert(ex == "-0X0.P+0"); 23165 assert(ios.width() == 0); 23166 } 23167 ios.width(25); 23168 left(ios); 23169 { 23170 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23171 std::string ex(str, iter.base()); 23172 assert(ex == "-0X0.P+0*****************"); 23173 assert(ios.width() == 0); 23174 } 23175 ios.width(25); 23176 right(ios); 23177 { 23178 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23179 std::string ex(str, iter.base()); 23180 assert(ex == "*****************-0X0.P+0"); 23181 assert(ios.width() == 0); 23182 } 23183 ios.width(25); 23184 internal(ios); 23185 { 23186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23187 std::string ex(str, iter.base()); 23188 assert(ex == "-*****************0X0.P+0"); 23189 assert(ios.width() == 0); 23190 } 23191 } 23192 ios.imbue(lg); 23193 { 23194 ios.width(0); 23195 { 23196 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23197 std::string ex(str, iter.base()); 23198 assert(ex == "-0X0;P+0"); 23199 assert(ios.width() == 0); 23200 } 23201 ios.width(25); 23202 left(ios); 23203 { 23204 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23205 std::string ex(str, iter.base()); 23206 assert(ex == "-0X0;P+0*****************"); 23207 assert(ios.width() == 0); 23208 } 23209 ios.width(25); 23210 right(ios); 23211 { 23212 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23213 std::string ex(str, iter.base()); 23214 assert(ex == "*****************-0X0;P+0"); 23215 assert(ios.width() == 0); 23216 } 23217 ios.width(25); 23218 internal(ios); 23219 { 23220 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23221 std::string ex(str, iter.base()); 23222 assert(ex == "-*****************0X0;P+0"); 23223 assert(ios.width() == 0); 23224 } 23225 } 23226 } 23227 } 23228 } 23229 } 23230 ios.precision(1); 23231 { 23232 nouppercase(ios); 23233 { 23234 noshowpos(ios); 23235 { 23236 noshowpoint(ios); 23237 { 23238 ios.imbue(lc); 23239 { 23240 ios.width(0); 23241 { 23242 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23243 std::string ex(str, iter.base()); 23244 assert(ex == "-0x0p+0"); 23245 assert(ios.width() == 0); 23246 } 23247 ios.width(25); 23248 left(ios); 23249 { 23250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23251 std::string ex(str, iter.base()); 23252 assert(ex == "-0x0p+0******************"); 23253 assert(ios.width() == 0); 23254 } 23255 ios.width(25); 23256 right(ios); 23257 { 23258 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23259 std::string ex(str, iter.base()); 23260 assert(ex == "******************-0x0p+0"); 23261 assert(ios.width() == 0); 23262 } 23263 ios.width(25); 23264 internal(ios); 23265 { 23266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23267 std::string ex(str, iter.base()); 23268 assert(ex == "-******************0x0p+0"); 23269 assert(ios.width() == 0); 23270 } 23271 } 23272 ios.imbue(lg); 23273 { 23274 ios.width(0); 23275 { 23276 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23277 std::string ex(str, iter.base()); 23278 assert(ex == "-0x0p+0"); 23279 assert(ios.width() == 0); 23280 } 23281 ios.width(25); 23282 left(ios); 23283 { 23284 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23285 std::string ex(str, iter.base()); 23286 assert(ex == "-0x0p+0******************"); 23287 assert(ios.width() == 0); 23288 } 23289 ios.width(25); 23290 right(ios); 23291 { 23292 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23293 std::string ex(str, iter.base()); 23294 assert(ex == "******************-0x0p+0"); 23295 assert(ios.width() == 0); 23296 } 23297 ios.width(25); 23298 internal(ios); 23299 { 23300 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23301 std::string ex(str, iter.base()); 23302 assert(ex == "-******************0x0p+0"); 23303 assert(ios.width() == 0); 23304 } 23305 } 23306 } 23307 showpoint(ios); 23308 { 23309 ios.imbue(lc); 23310 { 23311 ios.width(0); 23312 { 23313 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23314 std::string ex(str, iter.base()); 23315 assert(ex == "-0x0.p+0"); 23316 assert(ios.width() == 0); 23317 } 23318 ios.width(25); 23319 left(ios); 23320 { 23321 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23322 std::string ex(str, iter.base()); 23323 assert(ex == "-0x0.p+0*****************"); 23324 assert(ios.width() == 0); 23325 } 23326 ios.width(25); 23327 right(ios); 23328 { 23329 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23330 std::string ex(str, iter.base()); 23331 assert(ex == "*****************-0x0.p+0"); 23332 assert(ios.width() == 0); 23333 } 23334 ios.width(25); 23335 internal(ios); 23336 { 23337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23338 std::string ex(str, iter.base()); 23339 assert(ex == "-*****************0x0.p+0"); 23340 assert(ios.width() == 0); 23341 } 23342 } 23343 ios.imbue(lg); 23344 { 23345 ios.width(0); 23346 { 23347 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23348 std::string ex(str, iter.base()); 23349 assert(ex == "-0x0;p+0"); 23350 assert(ios.width() == 0); 23351 } 23352 ios.width(25); 23353 left(ios); 23354 { 23355 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23356 std::string ex(str, iter.base()); 23357 assert(ex == "-0x0;p+0*****************"); 23358 assert(ios.width() == 0); 23359 } 23360 ios.width(25); 23361 right(ios); 23362 { 23363 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23364 std::string ex(str, iter.base()); 23365 assert(ex == "*****************-0x0;p+0"); 23366 assert(ios.width() == 0); 23367 } 23368 ios.width(25); 23369 internal(ios); 23370 { 23371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23372 std::string ex(str, iter.base()); 23373 assert(ex == "-*****************0x0;p+0"); 23374 assert(ios.width() == 0); 23375 } 23376 } 23377 } 23378 } 23379 showpos(ios); 23380 { 23381 noshowpoint(ios); 23382 { 23383 ios.imbue(lc); 23384 { 23385 ios.width(0); 23386 { 23387 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23388 std::string ex(str, iter.base()); 23389 assert(ex == "-0x0p+0"); 23390 assert(ios.width() == 0); 23391 } 23392 ios.width(25); 23393 left(ios); 23394 { 23395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23396 std::string ex(str, iter.base()); 23397 assert(ex == "-0x0p+0******************"); 23398 assert(ios.width() == 0); 23399 } 23400 ios.width(25); 23401 right(ios); 23402 { 23403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23404 std::string ex(str, iter.base()); 23405 assert(ex == "******************-0x0p+0"); 23406 assert(ios.width() == 0); 23407 } 23408 ios.width(25); 23409 internal(ios); 23410 { 23411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23412 std::string ex(str, iter.base()); 23413 assert(ex == "-******************0x0p+0"); 23414 assert(ios.width() == 0); 23415 } 23416 } 23417 ios.imbue(lg); 23418 { 23419 ios.width(0); 23420 { 23421 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23422 std::string ex(str, iter.base()); 23423 assert(ex == "-0x0p+0"); 23424 assert(ios.width() == 0); 23425 } 23426 ios.width(25); 23427 left(ios); 23428 { 23429 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23430 std::string ex(str, iter.base()); 23431 assert(ex == "-0x0p+0******************"); 23432 assert(ios.width() == 0); 23433 } 23434 ios.width(25); 23435 right(ios); 23436 { 23437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23438 std::string ex(str, iter.base()); 23439 assert(ex == "******************-0x0p+0"); 23440 assert(ios.width() == 0); 23441 } 23442 ios.width(25); 23443 internal(ios); 23444 { 23445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23446 std::string ex(str, iter.base()); 23447 assert(ex == "-******************0x0p+0"); 23448 assert(ios.width() == 0); 23449 } 23450 } 23451 } 23452 showpoint(ios); 23453 { 23454 ios.imbue(lc); 23455 { 23456 ios.width(0); 23457 { 23458 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23459 std::string ex(str, iter.base()); 23460 assert(ex == "-0x0.p+0"); 23461 assert(ios.width() == 0); 23462 } 23463 ios.width(25); 23464 left(ios); 23465 { 23466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23467 std::string ex(str, iter.base()); 23468 assert(ex == "-0x0.p+0*****************"); 23469 assert(ios.width() == 0); 23470 } 23471 ios.width(25); 23472 right(ios); 23473 { 23474 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23475 std::string ex(str, iter.base()); 23476 assert(ex == "*****************-0x0.p+0"); 23477 assert(ios.width() == 0); 23478 } 23479 ios.width(25); 23480 internal(ios); 23481 { 23482 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23483 std::string ex(str, iter.base()); 23484 assert(ex == "-*****************0x0.p+0"); 23485 assert(ios.width() == 0); 23486 } 23487 } 23488 ios.imbue(lg); 23489 { 23490 ios.width(0); 23491 { 23492 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23493 std::string ex(str, iter.base()); 23494 assert(ex == "-0x0;p+0"); 23495 assert(ios.width() == 0); 23496 } 23497 ios.width(25); 23498 left(ios); 23499 { 23500 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23501 std::string ex(str, iter.base()); 23502 assert(ex == "-0x0;p+0*****************"); 23503 assert(ios.width() == 0); 23504 } 23505 ios.width(25); 23506 right(ios); 23507 { 23508 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23509 std::string ex(str, iter.base()); 23510 assert(ex == "*****************-0x0;p+0"); 23511 assert(ios.width() == 0); 23512 } 23513 ios.width(25); 23514 internal(ios); 23515 { 23516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23517 std::string ex(str, iter.base()); 23518 assert(ex == "-*****************0x0;p+0"); 23519 assert(ios.width() == 0); 23520 } 23521 } 23522 } 23523 } 23524 } 23525 uppercase(ios); 23526 { 23527 noshowpos(ios); 23528 { 23529 noshowpoint(ios); 23530 { 23531 ios.imbue(lc); 23532 { 23533 ios.width(0); 23534 { 23535 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23536 std::string ex(str, iter.base()); 23537 assert(ex == "-0X0P+0"); 23538 assert(ios.width() == 0); 23539 } 23540 ios.width(25); 23541 left(ios); 23542 { 23543 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23544 std::string ex(str, iter.base()); 23545 assert(ex == "-0X0P+0******************"); 23546 assert(ios.width() == 0); 23547 } 23548 ios.width(25); 23549 right(ios); 23550 { 23551 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23552 std::string ex(str, iter.base()); 23553 assert(ex == "******************-0X0P+0"); 23554 assert(ios.width() == 0); 23555 } 23556 ios.width(25); 23557 internal(ios); 23558 { 23559 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23560 std::string ex(str, iter.base()); 23561 assert(ex == "-******************0X0P+0"); 23562 assert(ios.width() == 0); 23563 } 23564 } 23565 ios.imbue(lg); 23566 { 23567 ios.width(0); 23568 { 23569 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23570 std::string ex(str, iter.base()); 23571 assert(ex == "-0X0P+0"); 23572 assert(ios.width() == 0); 23573 } 23574 ios.width(25); 23575 left(ios); 23576 { 23577 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23578 std::string ex(str, iter.base()); 23579 assert(ex == "-0X0P+0******************"); 23580 assert(ios.width() == 0); 23581 } 23582 ios.width(25); 23583 right(ios); 23584 { 23585 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23586 std::string ex(str, iter.base()); 23587 assert(ex == "******************-0X0P+0"); 23588 assert(ios.width() == 0); 23589 } 23590 ios.width(25); 23591 internal(ios); 23592 { 23593 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23594 std::string ex(str, iter.base()); 23595 assert(ex == "-******************0X0P+0"); 23596 assert(ios.width() == 0); 23597 } 23598 } 23599 } 23600 showpoint(ios); 23601 { 23602 ios.imbue(lc); 23603 { 23604 ios.width(0); 23605 { 23606 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23607 std::string ex(str, iter.base()); 23608 assert(ex == "-0X0.P+0"); 23609 assert(ios.width() == 0); 23610 } 23611 ios.width(25); 23612 left(ios); 23613 { 23614 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23615 std::string ex(str, iter.base()); 23616 assert(ex == "-0X0.P+0*****************"); 23617 assert(ios.width() == 0); 23618 } 23619 ios.width(25); 23620 right(ios); 23621 { 23622 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23623 std::string ex(str, iter.base()); 23624 assert(ex == "*****************-0X0.P+0"); 23625 assert(ios.width() == 0); 23626 } 23627 ios.width(25); 23628 internal(ios); 23629 { 23630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23631 std::string ex(str, iter.base()); 23632 assert(ex == "-*****************0X0.P+0"); 23633 assert(ios.width() == 0); 23634 } 23635 } 23636 ios.imbue(lg); 23637 { 23638 ios.width(0); 23639 { 23640 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23641 std::string ex(str, iter.base()); 23642 assert(ex == "-0X0;P+0"); 23643 assert(ios.width() == 0); 23644 } 23645 ios.width(25); 23646 left(ios); 23647 { 23648 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23649 std::string ex(str, iter.base()); 23650 assert(ex == "-0X0;P+0*****************"); 23651 assert(ios.width() == 0); 23652 } 23653 ios.width(25); 23654 right(ios); 23655 { 23656 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23657 std::string ex(str, iter.base()); 23658 assert(ex == "*****************-0X0;P+0"); 23659 assert(ios.width() == 0); 23660 } 23661 ios.width(25); 23662 internal(ios); 23663 { 23664 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23665 std::string ex(str, iter.base()); 23666 assert(ex == "-*****************0X0;P+0"); 23667 assert(ios.width() == 0); 23668 } 23669 } 23670 } 23671 } 23672 showpos(ios); 23673 { 23674 noshowpoint(ios); 23675 { 23676 ios.imbue(lc); 23677 { 23678 ios.width(0); 23679 { 23680 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23681 std::string ex(str, iter.base()); 23682 assert(ex == "-0X0P+0"); 23683 assert(ios.width() == 0); 23684 } 23685 ios.width(25); 23686 left(ios); 23687 { 23688 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23689 std::string ex(str, iter.base()); 23690 assert(ex == "-0X0P+0******************"); 23691 assert(ios.width() == 0); 23692 } 23693 ios.width(25); 23694 right(ios); 23695 { 23696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23697 std::string ex(str, iter.base()); 23698 assert(ex == "******************-0X0P+0"); 23699 assert(ios.width() == 0); 23700 } 23701 ios.width(25); 23702 internal(ios); 23703 { 23704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23705 std::string ex(str, iter.base()); 23706 assert(ex == "-******************0X0P+0"); 23707 assert(ios.width() == 0); 23708 } 23709 } 23710 ios.imbue(lg); 23711 { 23712 ios.width(0); 23713 { 23714 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23715 std::string ex(str, iter.base()); 23716 assert(ex == "-0X0P+0"); 23717 assert(ios.width() == 0); 23718 } 23719 ios.width(25); 23720 left(ios); 23721 { 23722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23723 std::string ex(str, iter.base()); 23724 assert(ex == "-0X0P+0******************"); 23725 assert(ios.width() == 0); 23726 } 23727 ios.width(25); 23728 right(ios); 23729 { 23730 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23731 std::string ex(str, iter.base()); 23732 assert(ex == "******************-0X0P+0"); 23733 assert(ios.width() == 0); 23734 } 23735 ios.width(25); 23736 internal(ios); 23737 { 23738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23739 std::string ex(str, iter.base()); 23740 assert(ex == "-******************0X0P+0"); 23741 assert(ios.width() == 0); 23742 } 23743 } 23744 } 23745 showpoint(ios); 23746 { 23747 ios.imbue(lc); 23748 { 23749 ios.width(0); 23750 { 23751 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23752 std::string ex(str, iter.base()); 23753 assert(ex == "-0X0.P+0"); 23754 assert(ios.width() == 0); 23755 } 23756 ios.width(25); 23757 left(ios); 23758 { 23759 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23760 std::string ex(str, iter.base()); 23761 assert(ex == "-0X0.P+0*****************"); 23762 assert(ios.width() == 0); 23763 } 23764 ios.width(25); 23765 right(ios); 23766 { 23767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23768 std::string ex(str, iter.base()); 23769 assert(ex == "*****************-0X0.P+0"); 23770 assert(ios.width() == 0); 23771 } 23772 ios.width(25); 23773 internal(ios); 23774 { 23775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23776 std::string ex(str, iter.base()); 23777 assert(ex == "-*****************0X0.P+0"); 23778 assert(ios.width() == 0); 23779 } 23780 } 23781 ios.imbue(lg); 23782 { 23783 ios.width(0); 23784 { 23785 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23786 std::string ex(str, iter.base()); 23787 assert(ex == "-0X0;P+0"); 23788 assert(ios.width() == 0); 23789 } 23790 ios.width(25); 23791 left(ios); 23792 { 23793 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23794 std::string ex(str, iter.base()); 23795 assert(ex == "-0X0;P+0*****************"); 23796 assert(ios.width() == 0); 23797 } 23798 ios.width(25); 23799 right(ios); 23800 { 23801 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23802 std::string ex(str, iter.base()); 23803 assert(ex == "*****************-0X0;P+0"); 23804 assert(ios.width() == 0); 23805 } 23806 ios.width(25); 23807 internal(ios); 23808 { 23809 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23810 std::string ex(str, iter.base()); 23811 assert(ex == "-*****************0X0;P+0"); 23812 assert(ios.width() == 0); 23813 } 23814 } 23815 } 23816 } 23817 } 23818 } 23819 ios.precision(6); 23820 { 23821 nouppercase(ios); 23822 { 23823 noshowpos(ios); 23824 { 23825 noshowpoint(ios); 23826 { 23827 ios.imbue(lc); 23828 { 23829 ios.width(0); 23830 { 23831 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23832 std::string ex(str, iter.base()); 23833 assert(ex == "-0x0p+0"); 23834 assert(ios.width() == 0); 23835 } 23836 ios.width(25); 23837 left(ios); 23838 { 23839 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23840 std::string ex(str, iter.base()); 23841 assert(ex == "-0x0p+0******************"); 23842 assert(ios.width() == 0); 23843 } 23844 ios.width(25); 23845 right(ios); 23846 { 23847 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23848 std::string ex(str, iter.base()); 23849 assert(ex == "******************-0x0p+0"); 23850 assert(ios.width() == 0); 23851 } 23852 ios.width(25); 23853 internal(ios); 23854 { 23855 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23856 std::string ex(str, iter.base()); 23857 assert(ex == "-******************0x0p+0"); 23858 assert(ios.width() == 0); 23859 } 23860 } 23861 ios.imbue(lg); 23862 { 23863 ios.width(0); 23864 { 23865 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23866 std::string ex(str, iter.base()); 23867 assert(ex == "-0x0p+0"); 23868 assert(ios.width() == 0); 23869 } 23870 ios.width(25); 23871 left(ios); 23872 { 23873 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23874 std::string ex(str, iter.base()); 23875 assert(ex == "-0x0p+0******************"); 23876 assert(ios.width() == 0); 23877 } 23878 ios.width(25); 23879 right(ios); 23880 { 23881 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23882 std::string ex(str, iter.base()); 23883 assert(ex == "******************-0x0p+0"); 23884 assert(ios.width() == 0); 23885 } 23886 ios.width(25); 23887 internal(ios); 23888 { 23889 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23890 std::string ex(str, iter.base()); 23891 assert(ex == "-******************0x0p+0"); 23892 assert(ios.width() == 0); 23893 } 23894 } 23895 } 23896 showpoint(ios); 23897 { 23898 ios.imbue(lc); 23899 { 23900 ios.width(0); 23901 { 23902 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23903 std::string ex(str, iter.base()); 23904 assert(ex == "-0x0.p+0"); 23905 assert(ios.width() == 0); 23906 } 23907 ios.width(25); 23908 left(ios); 23909 { 23910 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23911 std::string ex(str, iter.base()); 23912 assert(ex == "-0x0.p+0*****************"); 23913 assert(ios.width() == 0); 23914 } 23915 ios.width(25); 23916 right(ios); 23917 { 23918 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23919 std::string ex(str, iter.base()); 23920 assert(ex == "*****************-0x0.p+0"); 23921 assert(ios.width() == 0); 23922 } 23923 ios.width(25); 23924 internal(ios); 23925 { 23926 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23927 std::string ex(str, iter.base()); 23928 assert(ex == "-*****************0x0.p+0"); 23929 assert(ios.width() == 0); 23930 } 23931 } 23932 ios.imbue(lg); 23933 { 23934 ios.width(0); 23935 { 23936 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23937 std::string ex(str, iter.base()); 23938 assert(ex == "-0x0;p+0"); 23939 assert(ios.width() == 0); 23940 } 23941 ios.width(25); 23942 left(ios); 23943 { 23944 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23945 std::string ex(str, iter.base()); 23946 assert(ex == "-0x0;p+0*****************"); 23947 assert(ios.width() == 0); 23948 } 23949 ios.width(25); 23950 right(ios); 23951 { 23952 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23953 std::string ex(str, iter.base()); 23954 assert(ex == "*****************-0x0;p+0"); 23955 assert(ios.width() == 0); 23956 } 23957 ios.width(25); 23958 internal(ios); 23959 { 23960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23961 std::string ex(str, iter.base()); 23962 assert(ex == "-*****************0x0;p+0"); 23963 assert(ios.width() == 0); 23964 } 23965 } 23966 } 23967 } 23968 showpos(ios); 23969 { 23970 noshowpoint(ios); 23971 { 23972 ios.imbue(lc); 23973 { 23974 ios.width(0); 23975 { 23976 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23977 std::string ex(str, iter.base()); 23978 assert(ex == "-0x0p+0"); 23979 assert(ios.width() == 0); 23980 } 23981 ios.width(25); 23982 left(ios); 23983 { 23984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23985 std::string ex(str, iter.base()); 23986 assert(ex == "-0x0p+0******************"); 23987 assert(ios.width() == 0); 23988 } 23989 ios.width(25); 23990 right(ios); 23991 { 23992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 23993 std::string ex(str, iter.base()); 23994 assert(ex == "******************-0x0p+0"); 23995 assert(ios.width() == 0); 23996 } 23997 ios.width(25); 23998 internal(ios); 23999 { 24000 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24001 std::string ex(str, iter.base()); 24002 assert(ex == "-******************0x0p+0"); 24003 assert(ios.width() == 0); 24004 } 24005 } 24006 ios.imbue(lg); 24007 { 24008 ios.width(0); 24009 { 24010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24011 std::string ex(str, iter.base()); 24012 assert(ex == "-0x0p+0"); 24013 assert(ios.width() == 0); 24014 } 24015 ios.width(25); 24016 left(ios); 24017 { 24018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24019 std::string ex(str, iter.base()); 24020 assert(ex == "-0x0p+0******************"); 24021 assert(ios.width() == 0); 24022 } 24023 ios.width(25); 24024 right(ios); 24025 { 24026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24027 std::string ex(str, iter.base()); 24028 assert(ex == "******************-0x0p+0"); 24029 assert(ios.width() == 0); 24030 } 24031 ios.width(25); 24032 internal(ios); 24033 { 24034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24035 std::string ex(str, iter.base()); 24036 assert(ex == "-******************0x0p+0"); 24037 assert(ios.width() == 0); 24038 } 24039 } 24040 } 24041 showpoint(ios); 24042 { 24043 ios.imbue(lc); 24044 { 24045 ios.width(0); 24046 { 24047 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24048 std::string ex(str, iter.base()); 24049 assert(ex == "-0x0.p+0"); 24050 assert(ios.width() == 0); 24051 } 24052 ios.width(25); 24053 left(ios); 24054 { 24055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24056 std::string ex(str, iter.base()); 24057 assert(ex == "-0x0.p+0*****************"); 24058 assert(ios.width() == 0); 24059 } 24060 ios.width(25); 24061 right(ios); 24062 { 24063 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24064 std::string ex(str, iter.base()); 24065 assert(ex == "*****************-0x0.p+0"); 24066 assert(ios.width() == 0); 24067 } 24068 ios.width(25); 24069 internal(ios); 24070 { 24071 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24072 std::string ex(str, iter.base()); 24073 assert(ex == "-*****************0x0.p+0"); 24074 assert(ios.width() == 0); 24075 } 24076 } 24077 ios.imbue(lg); 24078 { 24079 ios.width(0); 24080 { 24081 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24082 std::string ex(str, iter.base()); 24083 assert(ex == "-0x0;p+0"); 24084 assert(ios.width() == 0); 24085 } 24086 ios.width(25); 24087 left(ios); 24088 { 24089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24090 std::string ex(str, iter.base()); 24091 assert(ex == "-0x0;p+0*****************"); 24092 assert(ios.width() == 0); 24093 } 24094 ios.width(25); 24095 right(ios); 24096 { 24097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24098 std::string ex(str, iter.base()); 24099 assert(ex == "*****************-0x0;p+0"); 24100 assert(ios.width() == 0); 24101 } 24102 ios.width(25); 24103 internal(ios); 24104 { 24105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24106 std::string ex(str, iter.base()); 24107 assert(ex == "-*****************0x0;p+0"); 24108 assert(ios.width() == 0); 24109 } 24110 } 24111 } 24112 } 24113 } 24114 uppercase(ios); 24115 { 24116 noshowpos(ios); 24117 { 24118 noshowpoint(ios); 24119 { 24120 ios.imbue(lc); 24121 { 24122 ios.width(0); 24123 { 24124 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24125 std::string ex(str, iter.base()); 24126 assert(ex == "-0X0P+0"); 24127 assert(ios.width() == 0); 24128 } 24129 ios.width(25); 24130 left(ios); 24131 { 24132 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24133 std::string ex(str, iter.base()); 24134 assert(ex == "-0X0P+0******************"); 24135 assert(ios.width() == 0); 24136 } 24137 ios.width(25); 24138 right(ios); 24139 { 24140 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24141 std::string ex(str, iter.base()); 24142 assert(ex == "******************-0X0P+0"); 24143 assert(ios.width() == 0); 24144 } 24145 ios.width(25); 24146 internal(ios); 24147 { 24148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24149 std::string ex(str, iter.base()); 24150 assert(ex == "-******************0X0P+0"); 24151 assert(ios.width() == 0); 24152 } 24153 } 24154 ios.imbue(lg); 24155 { 24156 ios.width(0); 24157 { 24158 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24159 std::string ex(str, iter.base()); 24160 assert(ex == "-0X0P+0"); 24161 assert(ios.width() == 0); 24162 } 24163 ios.width(25); 24164 left(ios); 24165 { 24166 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24167 std::string ex(str, iter.base()); 24168 assert(ex == "-0X0P+0******************"); 24169 assert(ios.width() == 0); 24170 } 24171 ios.width(25); 24172 right(ios); 24173 { 24174 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24175 std::string ex(str, iter.base()); 24176 assert(ex == "******************-0X0P+0"); 24177 assert(ios.width() == 0); 24178 } 24179 ios.width(25); 24180 internal(ios); 24181 { 24182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24183 std::string ex(str, iter.base()); 24184 assert(ex == "-******************0X0P+0"); 24185 assert(ios.width() == 0); 24186 } 24187 } 24188 } 24189 showpoint(ios); 24190 { 24191 ios.imbue(lc); 24192 { 24193 ios.width(0); 24194 { 24195 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24196 std::string ex(str, iter.base()); 24197 assert(ex == "-0X0.P+0"); 24198 assert(ios.width() == 0); 24199 } 24200 ios.width(25); 24201 left(ios); 24202 { 24203 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24204 std::string ex(str, iter.base()); 24205 assert(ex == "-0X0.P+0*****************"); 24206 assert(ios.width() == 0); 24207 } 24208 ios.width(25); 24209 right(ios); 24210 { 24211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24212 std::string ex(str, iter.base()); 24213 assert(ex == "*****************-0X0.P+0"); 24214 assert(ios.width() == 0); 24215 } 24216 ios.width(25); 24217 internal(ios); 24218 { 24219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24220 std::string ex(str, iter.base()); 24221 assert(ex == "-*****************0X0.P+0"); 24222 assert(ios.width() == 0); 24223 } 24224 } 24225 ios.imbue(lg); 24226 { 24227 ios.width(0); 24228 { 24229 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24230 std::string ex(str, iter.base()); 24231 assert(ex == "-0X0;P+0"); 24232 assert(ios.width() == 0); 24233 } 24234 ios.width(25); 24235 left(ios); 24236 { 24237 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24238 std::string ex(str, iter.base()); 24239 assert(ex == "-0X0;P+0*****************"); 24240 assert(ios.width() == 0); 24241 } 24242 ios.width(25); 24243 right(ios); 24244 { 24245 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24246 std::string ex(str, iter.base()); 24247 assert(ex == "*****************-0X0;P+0"); 24248 assert(ios.width() == 0); 24249 } 24250 ios.width(25); 24251 internal(ios); 24252 { 24253 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24254 std::string ex(str, iter.base()); 24255 assert(ex == "-*****************0X0;P+0"); 24256 assert(ios.width() == 0); 24257 } 24258 } 24259 } 24260 } 24261 showpos(ios); 24262 { 24263 noshowpoint(ios); 24264 { 24265 ios.imbue(lc); 24266 { 24267 ios.width(0); 24268 { 24269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24270 std::string ex(str, iter.base()); 24271 assert(ex == "-0X0P+0"); 24272 assert(ios.width() == 0); 24273 } 24274 ios.width(25); 24275 left(ios); 24276 { 24277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24278 std::string ex(str, iter.base()); 24279 assert(ex == "-0X0P+0******************"); 24280 assert(ios.width() == 0); 24281 } 24282 ios.width(25); 24283 right(ios); 24284 { 24285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24286 std::string ex(str, iter.base()); 24287 assert(ex == "******************-0X0P+0"); 24288 assert(ios.width() == 0); 24289 } 24290 ios.width(25); 24291 internal(ios); 24292 { 24293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24294 std::string ex(str, iter.base()); 24295 assert(ex == "-******************0X0P+0"); 24296 assert(ios.width() == 0); 24297 } 24298 } 24299 ios.imbue(lg); 24300 { 24301 ios.width(0); 24302 { 24303 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24304 std::string ex(str, iter.base()); 24305 assert(ex == "-0X0P+0"); 24306 assert(ios.width() == 0); 24307 } 24308 ios.width(25); 24309 left(ios); 24310 { 24311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24312 std::string ex(str, iter.base()); 24313 assert(ex == "-0X0P+0******************"); 24314 assert(ios.width() == 0); 24315 } 24316 ios.width(25); 24317 right(ios); 24318 { 24319 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24320 std::string ex(str, iter.base()); 24321 assert(ex == "******************-0X0P+0"); 24322 assert(ios.width() == 0); 24323 } 24324 ios.width(25); 24325 internal(ios); 24326 { 24327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24328 std::string ex(str, iter.base()); 24329 assert(ex == "-******************0X0P+0"); 24330 assert(ios.width() == 0); 24331 } 24332 } 24333 } 24334 showpoint(ios); 24335 { 24336 ios.imbue(lc); 24337 { 24338 ios.width(0); 24339 { 24340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24341 std::string ex(str, iter.base()); 24342 assert(ex == "-0X0.P+0"); 24343 assert(ios.width() == 0); 24344 } 24345 ios.width(25); 24346 left(ios); 24347 { 24348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24349 std::string ex(str, iter.base()); 24350 assert(ex == "-0X0.P+0*****************"); 24351 assert(ios.width() == 0); 24352 } 24353 ios.width(25); 24354 right(ios); 24355 { 24356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24357 std::string ex(str, iter.base()); 24358 assert(ex == "*****************-0X0.P+0"); 24359 assert(ios.width() == 0); 24360 } 24361 ios.width(25); 24362 internal(ios); 24363 { 24364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24365 std::string ex(str, iter.base()); 24366 assert(ex == "-*****************0X0.P+0"); 24367 assert(ios.width() == 0); 24368 } 24369 } 24370 ios.imbue(lg); 24371 { 24372 ios.width(0); 24373 { 24374 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24375 std::string ex(str, iter.base()); 24376 assert(ex == "-0X0;P+0"); 24377 assert(ios.width() == 0); 24378 } 24379 ios.width(25); 24380 left(ios); 24381 { 24382 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24383 std::string ex(str, iter.base()); 24384 assert(ex == "-0X0;P+0*****************"); 24385 assert(ios.width() == 0); 24386 } 24387 ios.width(25); 24388 right(ios); 24389 { 24390 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24391 std::string ex(str, iter.base()); 24392 assert(ex == "*****************-0X0;P+0"); 24393 assert(ios.width() == 0); 24394 } 24395 ios.width(25); 24396 internal(ios); 24397 { 24398 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24399 std::string ex(str, iter.base()); 24400 assert(ex == "-*****************0X0;P+0"); 24401 assert(ios.width() == 0); 24402 } 24403 } 24404 } 24405 } 24406 } 24407 } 24408 ios.precision(16); 24409 { 24410 } 24411 ios.precision(60); 24412 { 24413 } 24414 } 24415 } 24416 } 24417 24418 void test12() 24419 { 24420 output_iterator<char*> iter; 24421 std::locale lc = std::locale::classic(); 24422 std::locale lg(lc, new my_numpunct); 24423 #ifdef __APPLE__ 24424 // This test is failing on FreeBSD, possibly due to different representations 24425 // of the floating point numbers. 24426 const my_facet f(1); 24427 char str[200]; 24428 { 24429 long double v = 1234567890.125; 24430 std::ios ios(0); 24431 hexfloat(ios); 24432 // %a 24433 { 24434 ios.precision(0); 24435 { 24436 nouppercase(ios); 24437 { 24438 noshowpos(ios); 24439 { 24440 noshowpoint(ios); 24441 { 24442 ios.width(0); 24443 ios.imbue(lc); 24444 { 24445 { 24446 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24447 std::string ex(str, iter.base()); 24448 assert(ex == "0x9.32c05a44p+27"); 24449 assert(ios.width() == 0); 24450 } 24451 ios.width(25); 24452 left(ios); 24453 { 24454 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24455 std::string ex(str, iter.base()); 24456 assert(ex == "0x9.32c05a44p+27*********"); 24457 assert(ios.width() == 0); 24458 } 24459 ios.width(25); 24460 right(ios); 24461 { 24462 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24463 std::string ex(str, iter.base()); 24464 assert(ex == "*********0x9.32c05a44p+27"); 24465 assert(ios.width() == 0); 24466 } 24467 ios.width(25); 24468 internal(ios); 24469 { 24470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24471 std::string ex(str, iter.base()); 24472 assert(ex == "0x*********9.32c05a44p+27"); 24473 assert(ios.width() == 0); 24474 } 24475 } 24476 ios.imbue(lg); 24477 { 24478 ios.width(0); 24479 { 24480 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24481 std::string ex(str, iter.base()); 24482 assert(ex == "0x9;32c05a44p+27"); 24483 assert(ios.width() == 0); 24484 } 24485 ios.width(25); 24486 left(ios); 24487 { 24488 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24489 std::string ex(str, iter.base()); 24490 assert(ex == "0x9;32c05a44p+27*********"); 24491 assert(ios.width() == 0); 24492 } 24493 ios.width(25); 24494 right(ios); 24495 { 24496 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24497 std::string ex(str, iter.base()); 24498 assert(ex == "*********0x9;32c05a44p+27"); 24499 assert(ios.width() == 0); 24500 } 24501 ios.width(25); 24502 internal(ios); 24503 { 24504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24505 std::string ex(str, iter.base()); 24506 assert(ex == "0x*********9;32c05a44p+27"); 24507 assert(ios.width() == 0); 24508 } 24509 } 24510 } 24511 showpoint(ios); 24512 { 24513 ios.imbue(lc); 24514 { 24515 ios.width(0); 24516 { 24517 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24518 std::string ex(str, iter.base()); 24519 assert(ex == "0x9.32c05a44p+27"); 24520 assert(ios.width() == 0); 24521 } 24522 ios.width(25); 24523 left(ios); 24524 { 24525 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24526 std::string ex(str, iter.base()); 24527 assert(ex == "0x9.32c05a44p+27*********"); 24528 assert(ios.width() == 0); 24529 } 24530 ios.width(25); 24531 right(ios); 24532 { 24533 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24534 std::string ex(str, iter.base()); 24535 assert(ex == "*********0x9.32c05a44p+27"); 24536 assert(ios.width() == 0); 24537 } 24538 ios.width(25); 24539 internal(ios); 24540 { 24541 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24542 std::string ex(str, iter.base()); 24543 assert(ex == "0x*********9.32c05a44p+27"); 24544 assert(ios.width() == 0); 24545 } 24546 } 24547 ios.imbue(lg); 24548 { 24549 ios.width(0); 24550 { 24551 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24552 std::string ex(str, iter.base()); 24553 assert(ex == "0x9;32c05a44p+27"); 24554 assert(ios.width() == 0); 24555 } 24556 ios.width(25); 24557 left(ios); 24558 { 24559 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24560 std::string ex(str, iter.base()); 24561 assert(ex == "0x9;32c05a44p+27*********"); 24562 assert(ios.width() == 0); 24563 } 24564 ios.width(25); 24565 right(ios); 24566 { 24567 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24568 std::string ex(str, iter.base()); 24569 assert(ex == "*********0x9;32c05a44p+27"); 24570 assert(ios.width() == 0); 24571 } 24572 ios.width(25); 24573 internal(ios); 24574 { 24575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24576 std::string ex(str, iter.base()); 24577 assert(ex == "0x*********9;32c05a44p+27"); 24578 assert(ios.width() == 0); 24579 } 24580 } 24581 } 24582 } 24583 showpos(ios); 24584 { 24585 noshowpoint(ios); 24586 { 24587 ios.imbue(lc); 24588 { 24589 ios.width(0); 24590 { 24591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24592 std::string ex(str, iter.base()); 24593 assert(ex == "+0x9.32c05a44p+27"); 24594 assert(ios.width() == 0); 24595 } 24596 ios.width(25); 24597 left(ios); 24598 { 24599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24600 std::string ex(str, iter.base()); 24601 assert(ex == "+0x9.32c05a44p+27********"); 24602 assert(ios.width() == 0); 24603 } 24604 ios.width(25); 24605 right(ios); 24606 { 24607 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24608 std::string ex(str, iter.base()); 24609 assert(ex == "********+0x9.32c05a44p+27"); 24610 assert(ios.width() == 0); 24611 } 24612 ios.width(25); 24613 internal(ios); 24614 { 24615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24616 std::string ex(str, iter.base()); 24617 assert(ex == "+********0x9.32c05a44p+27"); 24618 assert(ios.width() == 0); 24619 } 24620 } 24621 ios.imbue(lg); 24622 { 24623 ios.width(0); 24624 { 24625 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24626 std::string ex(str, iter.base()); 24627 assert(ex == "+0x9;32c05a44p+27"); 24628 assert(ios.width() == 0); 24629 } 24630 ios.width(25); 24631 left(ios); 24632 { 24633 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24634 std::string ex(str, iter.base()); 24635 assert(ex == "+0x9;32c05a44p+27********"); 24636 assert(ios.width() == 0); 24637 } 24638 ios.width(25); 24639 right(ios); 24640 { 24641 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24642 std::string ex(str, iter.base()); 24643 assert(ex == "********+0x9;32c05a44p+27"); 24644 assert(ios.width() == 0); 24645 } 24646 ios.width(25); 24647 internal(ios); 24648 { 24649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24650 std::string ex(str, iter.base()); 24651 assert(ex == "+********0x9;32c05a44p+27"); 24652 assert(ios.width() == 0); 24653 } 24654 } 24655 } 24656 showpoint(ios); 24657 { 24658 ios.imbue(lc); 24659 { 24660 ios.width(0); 24661 { 24662 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24663 std::string ex(str, iter.base()); 24664 assert(ex == "+0x9.32c05a44p+27"); 24665 assert(ios.width() == 0); 24666 } 24667 ios.width(25); 24668 left(ios); 24669 { 24670 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24671 std::string ex(str, iter.base()); 24672 assert(ex == "+0x9.32c05a44p+27********"); 24673 assert(ios.width() == 0); 24674 } 24675 ios.width(25); 24676 right(ios); 24677 { 24678 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24679 std::string ex(str, iter.base()); 24680 assert(ex == "********+0x9.32c05a44p+27"); 24681 assert(ios.width() == 0); 24682 } 24683 ios.width(25); 24684 internal(ios); 24685 { 24686 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24687 std::string ex(str, iter.base()); 24688 assert(ex == "+********0x9.32c05a44p+27"); 24689 assert(ios.width() == 0); 24690 } 24691 } 24692 ios.imbue(lg); 24693 { 24694 ios.width(0); 24695 { 24696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24697 std::string ex(str, iter.base()); 24698 assert(ex == "+0x9;32c05a44p+27"); 24699 assert(ios.width() == 0); 24700 } 24701 ios.width(25); 24702 left(ios); 24703 { 24704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24705 std::string ex(str, iter.base()); 24706 assert(ex == "+0x9;32c05a44p+27********"); 24707 assert(ios.width() == 0); 24708 } 24709 ios.width(25); 24710 right(ios); 24711 { 24712 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24713 std::string ex(str, iter.base()); 24714 assert(ex == "********+0x9;32c05a44p+27"); 24715 assert(ios.width() == 0); 24716 } 24717 ios.width(25); 24718 internal(ios); 24719 { 24720 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24721 std::string ex(str, iter.base()); 24722 assert(ex == "+********0x9;32c05a44p+27"); 24723 assert(ios.width() == 0); 24724 } 24725 } 24726 } 24727 } 24728 } 24729 uppercase(ios); 24730 { 24731 noshowpos(ios); 24732 { 24733 noshowpoint(ios); 24734 { 24735 ios.imbue(lc); 24736 { 24737 ios.width(0); 24738 { 24739 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24740 std::string ex(str, iter.base()); 24741 assert(ex == "0X9.32C05A44P+27"); 24742 assert(ios.width() == 0); 24743 } 24744 ios.width(25); 24745 left(ios); 24746 { 24747 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24748 std::string ex(str, iter.base()); 24749 assert(ex == "0X9.32C05A44P+27*********"); 24750 assert(ios.width() == 0); 24751 } 24752 ios.width(25); 24753 right(ios); 24754 { 24755 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24756 std::string ex(str, iter.base()); 24757 assert(ex == "*********0X9.32C05A44P+27"); 24758 assert(ios.width() == 0); 24759 } 24760 ios.width(25); 24761 internal(ios); 24762 { 24763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24764 std::string ex(str, iter.base()); 24765 assert(ex == "0X*********9.32C05A44P+27"); 24766 assert(ios.width() == 0); 24767 } 24768 } 24769 ios.imbue(lg); 24770 { 24771 ios.width(0); 24772 { 24773 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24774 std::string ex(str, iter.base()); 24775 assert(ex == "0X9;32C05A44P+27"); 24776 assert(ios.width() == 0); 24777 } 24778 ios.width(25); 24779 left(ios); 24780 { 24781 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24782 std::string ex(str, iter.base()); 24783 assert(ex == "0X9;32C05A44P+27*********"); 24784 assert(ios.width() == 0); 24785 } 24786 ios.width(25); 24787 right(ios); 24788 { 24789 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24790 std::string ex(str, iter.base()); 24791 assert(ex == "*********0X9;32C05A44P+27"); 24792 assert(ios.width() == 0); 24793 } 24794 ios.width(25); 24795 internal(ios); 24796 { 24797 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24798 std::string ex(str, iter.base()); 24799 assert(ex == "0X*********9;32C05A44P+27"); 24800 assert(ios.width() == 0); 24801 } 24802 } 24803 } 24804 showpoint(ios); 24805 { 24806 ios.imbue(lc); 24807 { 24808 ios.width(0); 24809 { 24810 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24811 std::string ex(str, iter.base()); 24812 assert(ex == "0X9.32C05A44P+27"); 24813 assert(ios.width() == 0); 24814 } 24815 ios.width(25); 24816 left(ios); 24817 { 24818 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24819 std::string ex(str, iter.base()); 24820 assert(ex == "0X9.32C05A44P+27*********"); 24821 assert(ios.width() == 0); 24822 } 24823 ios.width(25); 24824 right(ios); 24825 { 24826 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24827 std::string ex(str, iter.base()); 24828 assert(ex == "*********0X9.32C05A44P+27"); 24829 assert(ios.width() == 0); 24830 } 24831 ios.width(25); 24832 internal(ios); 24833 { 24834 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24835 std::string ex(str, iter.base()); 24836 assert(ex == "0X*********9.32C05A44P+27"); 24837 assert(ios.width() == 0); 24838 } 24839 } 24840 ios.imbue(lg); 24841 { 24842 ios.width(0); 24843 { 24844 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24845 std::string ex(str, iter.base()); 24846 assert(ex == "0X9;32C05A44P+27"); 24847 assert(ios.width() == 0); 24848 } 24849 ios.width(25); 24850 left(ios); 24851 { 24852 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24853 std::string ex(str, iter.base()); 24854 assert(ex == "0X9;32C05A44P+27*********"); 24855 assert(ios.width() == 0); 24856 } 24857 ios.width(25); 24858 right(ios); 24859 { 24860 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24861 std::string ex(str, iter.base()); 24862 assert(ex == "*********0X9;32C05A44P+27"); 24863 assert(ios.width() == 0); 24864 } 24865 ios.width(25); 24866 internal(ios); 24867 { 24868 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24869 std::string ex(str, iter.base()); 24870 assert(ex == "0X*********9;32C05A44P+27"); 24871 assert(ios.width() == 0); 24872 } 24873 } 24874 } 24875 } 24876 showpos(ios); 24877 { 24878 noshowpoint(ios); 24879 { 24880 ios.imbue(lc); 24881 { 24882 ios.width(0); 24883 { 24884 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24885 std::string ex(str, iter.base()); 24886 assert(ex == "+0X9.32C05A44P+27"); 24887 assert(ios.width() == 0); 24888 } 24889 ios.width(25); 24890 left(ios); 24891 { 24892 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24893 std::string ex(str, iter.base()); 24894 assert(ex == "+0X9.32C05A44P+27********"); 24895 assert(ios.width() == 0); 24896 } 24897 ios.width(25); 24898 right(ios); 24899 { 24900 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24901 std::string ex(str, iter.base()); 24902 assert(ex == "********+0X9.32C05A44P+27"); 24903 assert(ios.width() == 0); 24904 } 24905 ios.width(25); 24906 internal(ios); 24907 { 24908 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24909 std::string ex(str, iter.base()); 24910 assert(ex == "+********0X9.32C05A44P+27"); 24911 assert(ios.width() == 0); 24912 } 24913 } 24914 ios.imbue(lg); 24915 { 24916 ios.width(0); 24917 { 24918 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24919 std::string ex(str, iter.base()); 24920 assert(ex == "+0X9;32C05A44P+27"); 24921 assert(ios.width() == 0); 24922 } 24923 ios.width(25); 24924 left(ios); 24925 { 24926 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24927 std::string ex(str, iter.base()); 24928 assert(ex == "+0X9;32C05A44P+27********"); 24929 assert(ios.width() == 0); 24930 } 24931 ios.width(25); 24932 right(ios); 24933 { 24934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24935 std::string ex(str, iter.base()); 24936 assert(ex == "********+0X9;32C05A44P+27"); 24937 assert(ios.width() == 0); 24938 } 24939 ios.width(25); 24940 internal(ios); 24941 { 24942 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24943 std::string ex(str, iter.base()); 24944 assert(ex == "+********0X9;32C05A44P+27"); 24945 assert(ios.width() == 0); 24946 } 24947 } 24948 } 24949 showpoint(ios); 24950 { 24951 ios.imbue(lc); 24952 { 24953 ios.width(0); 24954 { 24955 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24956 std::string ex(str, iter.base()); 24957 assert(ex == "+0X9.32C05A44P+27"); 24958 assert(ios.width() == 0); 24959 } 24960 ios.width(25); 24961 left(ios); 24962 { 24963 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24964 std::string ex(str, iter.base()); 24965 assert(ex == "+0X9.32C05A44P+27********"); 24966 assert(ios.width() == 0); 24967 } 24968 ios.width(25); 24969 right(ios); 24970 { 24971 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24972 std::string ex(str, iter.base()); 24973 assert(ex == "********+0X9.32C05A44P+27"); 24974 assert(ios.width() == 0); 24975 } 24976 ios.width(25); 24977 internal(ios); 24978 { 24979 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24980 std::string ex(str, iter.base()); 24981 assert(ex == "+********0X9.32C05A44P+27"); 24982 assert(ios.width() == 0); 24983 } 24984 } 24985 ios.imbue(lg); 24986 { 24987 ios.width(0); 24988 { 24989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24990 std::string ex(str, iter.base()); 24991 assert(ex == "+0X9;32C05A44P+27"); 24992 assert(ios.width() == 0); 24993 } 24994 ios.width(25); 24995 left(ios); 24996 { 24997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 24998 std::string ex(str, iter.base()); 24999 assert(ex == "+0X9;32C05A44P+27********"); 25000 assert(ios.width() == 0); 25001 } 25002 ios.width(25); 25003 right(ios); 25004 { 25005 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25006 std::string ex(str, iter.base()); 25007 assert(ex == "********+0X9;32C05A44P+27"); 25008 assert(ios.width() == 0); 25009 } 25010 ios.width(25); 25011 internal(ios); 25012 { 25013 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25014 std::string ex(str, iter.base()); 25015 assert(ex == "+********0X9;32C05A44P+27"); 25016 assert(ios.width() == 0); 25017 } 25018 } 25019 } 25020 } 25021 } 25022 } 25023 ios.precision(1); 25024 { 25025 nouppercase(ios); 25026 { 25027 noshowpos(ios); 25028 { 25029 noshowpoint(ios); 25030 { 25031 ios.imbue(lc); 25032 { 25033 ios.width(0); 25034 { 25035 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25036 std::string ex(str, iter.base()); 25037 assert(ex == "0x9.32c05a44p+27"); 25038 assert(ios.width() == 0); 25039 } 25040 ios.width(25); 25041 left(ios); 25042 { 25043 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25044 std::string ex(str, iter.base()); 25045 assert(ex == "0x9.32c05a44p+27*********"); 25046 assert(ios.width() == 0); 25047 } 25048 ios.width(25); 25049 right(ios); 25050 { 25051 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25052 std::string ex(str, iter.base()); 25053 assert(ex == "*********0x9.32c05a44p+27"); 25054 assert(ios.width() == 0); 25055 } 25056 ios.width(25); 25057 internal(ios); 25058 { 25059 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25060 std::string ex(str, iter.base()); 25061 assert(ex == "0x*********9.32c05a44p+27"); 25062 assert(ios.width() == 0); 25063 } 25064 } 25065 ios.imbue(lg); 25066 { 25067 ios.width(0); 25068 { 25069 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25070 std::string ex(str, iter.base()); 25071 assert(ex == "0x9;32c05a44p+27"); 25072 assert(ios.width() == 0); 25073 } 25074 ios.width(25); 25075 left(ios); 25076 { 25077 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25078 std::string ex(str, iter.base()); 25079 assert(ex == "0x9;32c05a44p+27*********"); 25080 assert(ios.width() == 0); 25081 } 25082 ios.width(25); 25083 right(ios); 25084 { 25085 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25086 std::string ex(str, iter.base()); 25087 assert(ex == "*********0x9;32c05a44p+27"); 25088 assert(ios.width() == 0); 25089 } 25090 ios.width(25); 25091 internal(ios); 25092 { 25093 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25094 std::string ex(str, iter.base()); 25095 assert(ex == "0x*********9;32c05a44p+27"); 25096 assert(ios.width() == 0); 25097 } 25098 } 25099 } 25100 showpoint(ios); 25101 { 25102 ios.imbue(lc); 25103 { 25104 ios.width(0); 25105 { 25106 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25107 std::string ex(str, iter.base()); 25108 assert(ex == "0x9.32c05a44p+27"); 25109 assert(ios.width() == 0); 25110 } 25111 ios.width(25); 25112 left(ios); 25113 { 25114 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25115 std::string ex(str, iter.base()); 25116 assert(ex == "0x9.32c05a44p+27*********"); 25117 assert(ios.width() == 0); 25118 } 25119 ios.width(25); 25120 right(ios); 25121 { 25122 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25123 std::string ex(str, iter.base()); 25124 assert(ex == "*********0x9.32c05a44p+27"); 25125 assert(ios.width() == 0); 25126 } 25127 ios.width(25); 25128 internal(ios); 25129 { 25130 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25131 std::string ex(str, iter.base()); 25132 assert(ex == "0x*********9.32c05a44p+27"); 25133 assert(ios.width() == 0); 25134 } 25135 } 25136 ios.imbue(lg); 25137 { 25138 ios.width(0); 25139 { 25140 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25141 std::string ex(str, iter.base()); 25142 assert(ex == "0x9;32c05a44p+27"); 25143 assert(ios.width() == 0); 25144 } 25145 ios.width(25); 25146 left(ios); 25147 { 25148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25149 std::string ex(str, iter.base()); 25150 assert(ex == "0x9;32c05a44p+27*********"); 25151 assert(ios.width() == 0); 25152 } 25153 ios.width(25); 25154 right(ios); 25155 { 25156 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25157 std::string ex(str, iter.base()); 25158 assert(ex == "*********0x9;32c05a44p+27"); 25159 assert(ios.width() == 0); 25160 } 25161 ios.width(25); 25162 internal(ios); 25163 { 25164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25165 std::string ex(str, iter.base()); 25166 assert(ex == "0x*********9;32c05a44p+27"); 25167 assert(ios.width() == 0); 25168 } 25169 } 25170 } 25171 } 25172 showpos(ios); 25173 { 25174 noshowpoint(ios); 25175 { 25176 ios.imbue(lc); 25177 { 25178 ios.width(0); 25179 { 25180 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25181 std::string ex(str, iter.base()); 25182 assert(ex == "+0x9.32c05a44p+27"); 25183 assert(ios.width() == 0); 25184 } 25185 ios.width(25); 25186 left(ios); 25187 { 25188 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25189 std::string ex(str, iter.base()); 25190 assert(ex == "+0x9.32c05a44p+27********"); 25191 assert(ios.width() == 0); 25192 } 25193 ios.width(25); 25194 right(ios); 25195 { 25196 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25197 std::string ex(str, iter.base()); 25198 assert(ex == "********+0x9.32c05a44p+27"); 25199 assert(ios.width() == 0); 25200 } 25201 ios.width(25); 25202 internal(ios); 25203 { 25204 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25205 std::string ex(str, iter.base()); 25206 assert(ex == "+********0x9.32c05a44p+27"); 25207 assert(ios.width() == 0); 25208 } 25209 } 25210 ios.imbue(lg); 25211 { 25212 ios.width(0); 25213 { 25214 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25215 std::string ex(str, iter.base()); 25216 assert(ex == "+0x9;32c05a44p+27"); 25217 assert(ios.width() == 0); 25218 } 25219 ios.width(25); 25220 left(ios); 25221 { 25222 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25223 std::string ex(str, iter.base()); 25224 assert(ex == "+0x9;32c05a44p+27********"); 25225 assert(ios.width() == 0); 25226 } 25227 ios.width(25); 25228 right(ios); 25229 { 25230 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25231 std::string ex(str, iter.base()); 25232 assert(ex == "********+0x9;32c05a44p+27"); 25233 assert(ios.width() == 0); 25234 } 25235 ios.width(25); 25236 internal(ios); 25237 { 25238 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25239 std::string ex(str, iter.base()); 25240 assert(ex == "+********0x9;32c05a44p+27"); 25241 assert(ios.width() == 0); 25242 } 25243 } 25244 } 25245 showpoint(ios); 25246 { 25247 ios.imbue(lc); 25248 { 25249 ios.width(0); 25250 { 25251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25252 std::string ex(str, iter.base()); 25253 assert(ex == "+0x9.32c05a44p+27"); 25254 assert(ios.width() == 0); 25255 } 25256 ios.width(25); 25257 left(ios); 25258 { 25259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25260 std::string ex(str, iter.base()); 25261 assert(ex == "+0x9.32c05a44p+27********"); 25262 assert(ios.width() == 0); 25263 } 25264 ios.width(25); 25265 right(ios); 25266 { 25267 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25268 std::string ex(str, iter.base()); 25269 assert(ex == "********+0x9.32c05a44p+27"); 25270 assert(ios.width() == 0); 25271 } 25272 ios.width(25); 25273 internal(ios); 25274 { 25275 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25276 std::string ex(str, iter.base()); 25277 assert(ex == "+********0x9.32c05a44p+27"); 25278 assert(ios.width() == 0); 25279 } 25280 } 25281 ios.imbue(lg); 25282 { 25283 ios.width(0); 25284 { 25285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25286 std::string ex(str, iter.base()); 25287 assert(ex == "+0x9;32c05a44p+27"); 25288 assert(ios.width() == 0); 25289 } 25290 ios.width(25); 25291 left(ios); 25292 { 25293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25294 std::string ex(str, iter.base()); 25295 assert(ex == "+0x9;32c05a44p+27********"); 25296 assert(ios.width() == 0); 25297 } 25298 ios.width(25); 25299 right(ios); 25300 { 25301 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25302 std::string ex(str, iter.base()); 25303 assert(ex == "********+0x9;32c05a44p+27"); 25304 assert(ios.width() == 0); 25305 } 25306 ios.width(25); 25307 internal(ios); 25308 { 25309 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25310 std::string ex(str, iter.base()); 25311 assert(ex == "+********0x9;32c05a44p+27"); 25312 assert(ios.width() == 0); 25313 } 25314 } 25315 } 25316 } 25317 } 25318 uppercase(ios); 25319 { 25320 noshowpos(ios); 25321 { 25322 noshowpoint(ios); 25323 { 25324 ios.imbue(lc); 25325 { 25326 ios.width(0); 25327 { 25328 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25329 std::string ex(str, iter.base()); 25330 assert(ex == "0X9.32C05A44P+27"); 25331 assert(ios.width() == 0); 25332 } 25333 ios.width(25); 25334 left(ios); 25335 { 25336 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25337 std::string ex(str, iter.base()); 25338 assert(ex == "0X9.32C05A44P+27*********"); 25339 assert(ios.width() == 0); 25340 } 25341 ios.width(25); 25342 right(ios); 25343 { 25344 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25345 std::string ex(str, iter.base()); 25346 assert(ex == "*********0X9.32C05A44P+27"); 25347 assert(ios.width() == 0); 25348 } 25349 ios.width(25); 25350 internal(ios); 25351 { 25352 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25353 std::string ex(str, iter.base()); 25354 assert(ex == "0X*********9.32C05A44P+27"); 25355 assert(ios.width() == 0); 25356 } 25357 } 25358 ios.imbue(lg); 25359 { 25360 ios.width(0); 25361 { 25362 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25363 std::string ex(str, iter.base()); 25364 assert(ex == "0X9;32C05A44P+27"); 25365 assert(ios.width() == 0); 25366 } 25367 ios.width(25); 25368 left(ios); 25369 { 25370 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25371 std::string ex(str, iter.base()); 25372 assert(ex == "0X9;32C05A44P+27*********"); 25373 assert(ios.width() == 0); 25374 } 25375 ios.width(25); 25376 right(ios); 25377 { 25378 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25379 std::string ex(str, iter.base()); 25380 assert(ex == "*********0X9;32C05A44P+27"); 25381 assert(ios.width() == 0); 25382 } 25383 ios.width(25); 25384 internal(ios); 25385 { 25386 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25387 std::string ex(str, iter.base()); 25388 assert(ex == "0X*********9;32C05A44P+27"); 25389 assert(ios.width() == 0); 25390 } 25391 } 25392 } 25393 showpoint(ios); 25394 { 25395 ios.imbue(lc); 25396 { 25397 ios.width(0); 25398 { 25399 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25400 std::string ex(str, iter.base()); 25401 assert(ex == "0X9.32C05A44P+27"); 25402 assert(ios.width() == 0); 25403 } 25404 ios.width(25); 25405 left(ios); 25406 { 25407 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25408 std::string ex(str, iter.base()); 25409 assert(ex == "0X9.32C05A44P+27*********"); 25410 assert(ios.width() == 0); 25411 } 25412 ios.width(25); 25413 right(ios); 25414 { 25415 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25416 std::string ex(str, iter.base()); 25417 assert(ex == "*********0X9.32C05A44P+27"); 25418 assert(ios.width() == 0); 25419 } 25420 ios.width(25); 25421 internal(ios); 25422 { 25423 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25424 std::string ex(str, iter.base()); 25425 assert(ex == "0X*********9.32C05A44P+27"); 25426 assert(ios.width() == 0); 25427 } 25428 } 25429 ios.imbue(lg); 25430 { 25431 ios.width(0); 25432 { 25433 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25434 std::string ex(str, iter.base()); 25435 assert(ex == "0X9;32C05A44P+27"); 25436 assert(ios.width() == 0); 25437 } 25438 ios.width(25); 25439 left(ios); 25440 { 25441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25442 std::string ex(str, iter.base()); 25443 assert(ex == "0X9;32C05A44P+27*********"); 25444 assert(ios.width() == 0); 25445 } 25446 ios.width(25); 25447 right(ios); 25448 { 25449 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25450 std::string ex(str, iter.base()); 25451 assert(ex == "*********0X9;32C05A44P+27"); 25452 assert(ios.width() == 0); 25453 } 25454 ios.width(25); 25455 internal(ios); 25456 { 25457 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25458 std::string ex(str, iter.base()); 25459 assert(ex == "0X*********9;32C05A44P+27"); 25460 assert(ios.width() == 0); 25461 } 25462 } 25463 } 25464 } 25465 showpos(ios); 25466 { 25467 noshowpoint(ios); 25468 { 25469 ios.imbue(lc); 25470 { 25471 ios.width(0); 25472 { 25473 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25474 std::string ex(str, iter.base()); 25475 assert(ex == "+0X9.32C05A44P+27"); 25476 assert(ios.width() == 0); 25477 } 25478 ios.width(25); 25479 left(ios); 25480 { 25481 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25482 std::string ex(str, iter.base()); 25483 assert(ex == "+0X9.32C05A44P+27********"); 25484 assert(ios.width() == 0); 25485 } 25486 ios.width(25); 25487 right(ios); 25488 { 25489 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25490 std::string ex(str, iter.base()); 25491 assert(ex == "********+0X9.32C05A44P+27"); 25492 assert(ios.width() == 0); 25493 } 25494 ios.width(25); 25495 internal(ios); 25496 { 25497 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25498 std::string ex(str, iter.base()); 25499 assert(ex == "+********0X9.32C05A44P+27"); 25500 assert(ios.width() == 0); 25501 } 25502 } 25503 ios.imbue(lg); 25504 { 25505 ios.width(0); 25506 { 25507 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25508 std::string ex(str, iter.base()); 25509 assert(ex == "+0X9;32C05A44P+27"); 25510 assert(ios.width() == 0); 25511 } 25512 ios.width(25); 25513 left(ios); 25514 { 25515 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25516 std::string ex(str, iter.base()); 25517 assert(ex == "+0X9;32C05A44P+27********"); 25518 assert(ios.width() == 0); 25519 } 25520 ios.width(25); 25521 right(ios); 25522 { 25523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25524 std::string ex(str, iter.base()); 25525 assert(ex == "********+0X9;32C05A44P+27"); 25526 assert(ios.width() == 0); 25527 } 25528 ios.width(25); 25529 internal(ios); 25530 { 25531 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25532 std::string ex(str, iter.base()); 25533 assert(ex == "+********0X9;32C05A44P+27"); 25534 assert(ios.width() == 0); 25535 } 25536 } 25537 } 25538 showpoint(ios); 25539 { 25540 ios.imbue(lc); 25541 { 25542 ios.width(0); 25543 { 25544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25545 std::string ex(str, iter.base()); 25546 assert(ex == "+0X9.32C05A44P+27"); 25547 assert(ios.width() == 0); 25548 } 25549 ios.width(25); 25550 left(ios); 25551 { 25552 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25553 std::string ex(str, iter.base()); 25554 assert(ex == "+0X9.32C05A44P+27********"); 25555 assert(ios.width() == 0); 25556 } 25557 ios.width(25); 25558 right(ios); 25559 { 25560 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25561 std::string ex(str, iter.base()); 25562 assert(ex == "********+0X9.32C05A44P+27"); 25563 assert(ios.width() == 0); 25564 } 25565 ios.width(25); 25566 internal(ios); 25567 { 25568 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25569 std::string ex(str, iter.base()); 25570 assert(ex == "+********0X9.32C05A44P+27"); 25571 assert(ios.width() == 0); 25572 } 25573 } 25574 ios.imbue(lg); 25575 { 25576 ios.width(0); 25577 { 25578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25579 std::string ex(str, iter.base()); 25580 assert(ex == "+0X9;32C05A44P+27"); 25581 assert(ios.width() == 0); 25582 } 25583 ios.width(25); 25584 left(ios); 25585 { 25586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25587 std::string ex(str, iter.base()); 25588 assert(ex == "+0X9;32C05A44P+27********"); 25589 assert(ios.width() == 0); 25590 } 25591 ios.width(25); 25592 right(ios); 25593 { 25594 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25595 std::string ex(str, iter.base()); 25596 assert(ex == "********+0X9;32C05A44P+27"); 25597 assert(ios.width() == 0); 25598 } 25599 ios.width(25); 25600 internal(ios); 25601 { 25602 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25603 std::string ex(str, iter.base()); 25604 assert(ex == "+********0X9;32C05A44P+27"); 25605 assert(ios.width() == 0); 25606 } 25607 } 25608 } 25609 } 25610 } 25611 } 25612 ios.precision(6); 25613 { 25614 } 25615 ios.precision(16); 25616 { 25617 } 25618 ios.precision(60); 25619 { 25620 nouppercase(ios); 25621 { 25622 noshowpos(ios); 25623 { 25624 noshowpoint(ios); 25625 { 25626 ios.imbue(lc); 25627 { 25628 ios.width(0); 25629 { 25630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25631 std::string ex(str, iter.base()); 25632 assert(ex == "0x9.32c05a44p+27"); 25633 assert(ios.width() == 0); 25634 } 25635 ios.width(25); 25636 left(ios); 25637 { 25638 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25639 std::string ex(str, iter.base()); 25640 assert(ex == "0x9.32c05a44p+27*********"); 25641 assert(ios.width() == 0); 25642 } 25643 ios.width(25); 25644 right(ios); 25645 { 25646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25647 std::string ex(str, iter.base()); 25648 assert(ex == "*********0x9.32c05a44p+27"); 25649 assert(ios.width() == 0); 25650 } 25651 ios.width(25); 25652 internal(ios); 25653 { 25654 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25655 std::string ex(str, iter.base()); 25656 assert(ex == "0x*********9.32c05a44p+27"); 25657 assert(ios.width() == 0); 25658 } 25659 } 25660 ios.imbue(lg); 25661 { 25662 ios.width(0); 25663 { 25664 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25665 std::string ex(str, iter.base()); 25666 assert(ex == "0x9;32c05a44p+27"); 25667 assert(ios.width() == 0); 25668 } 25669 ios.width(25); 25670 left(ios); 25671 { 25672 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25673 std::string ex(str, iter.base()); 25674 assert(ex == "0x9;32c05a44p+27*********"); 25675 assert(ios.width() == 0); 25676 } 25677 ios.width(25); 25678 right(ios); 25679 { 25680 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25681 std::string ex(str, iter.base()); 25682 assert(ex == "*********0x9;32c05a44p+27"); 25683 assert(ios.width() == 0); 25684 } 25685 ios.width(25); 25686 internal(ios); 25687 { 25688 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25689 std::string ex(str, iter.base()); 25690 assert(ex == "0x*********9;32c05a44p+27"); 25691 assert(ios.width() == 0); 25692 } 25693 } 25694 } 25695 showpoint(ios); 25696 { 25697 ios.imbue(lc); 25698 { 25699 ios.width(0); 25700 { 25701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25702 std::string ex(str, iter.base()); 25703 assert(ex == "0x9.32c05a44p+27"); 25704 assert(ios.width() == 0); 25705 } 25706 ios.width(25); 25707 left(ios); 25708 { 25709 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25710 std::string ex(str, iter.base()); 25711 assert(ex == "0x9.32c05a44p+27*********"); 25712 assert(ios.width() == 0); 25713 } 25714 ios.width(25); 25715 right(ios); 25716 { 25717 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25718 std::string ex(str, iter.base()); 25719 assert(ex == "*********0x9.32c05a44p+27"); 25720 assert(ios.width() == 0); 25721 } 25722 ios.width(25); 25723 internal(ios); 25724 { 25725 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25726 std::string ex(str, iter.base()); 25727 assert(ex == "0x*********9.32c05a44p+27"); 25728 assert(ios.width() == 0); 25729 } 25730 } 25731 ios.imbue(lg); 25732 { 25733 ios.width(0); 25734 { 25735 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25736 std::string ex(str, iter.base()); 25737 assert(ex == "0x9;32c05a44p+27"); 25738 assert(ios.width() == 0); 25739 } 25740 ios.width(25); 25741 left(ios); 25742 { 25743 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25744 std::string ex(str, iter.base()); 25745 assert(ex == "0x9;32c05a44p+27*********"); 25746 assert(ios.width() == 0); 25747 } 25748 ios.width(25); 25749 right(ios); 25750 { 25751 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25752 std::string ex(str, iter.base()); 25753 assert(ex == "*********0x9;32c05a44p+27"); 25754 assert(ios.width() == 0); 25755 } 25756 ios.width(25); 25757 internal(ios); 25758 { 25759 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25760 std::string ex(str, iter.base()); 25761 assert(ex == "0x*********9;32c05a44p+27"); 25762 assert(ios.width() == 0); 25763 } 25764 } 25765 } 25766 } 25767 showpos(ios); 25768 { 25769 noshowpoint(ios); 25770 { 25771 ios.imbue(lc); 25772 { 25773 ios.width(0); 25774 { 25775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25776 std::string ex(str, iter.base()); 25777 assert(ex == "+0x9.32c05a44p+27"); 25778 assert(ios.width() == 0); 25779 } 25780 ios.width(25); 25781 left(ios); 25782 { 25783 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25784 std::string ex(str, iter.base()); 25785 assert(ex == "+0x9.32c05a44p+27********"); 25786 assert(ios.width() == 0); 25787 } 25788 ios.width(25); 25789 right(ios); 25790 { 25791 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25792 std::string ex(str, iter.base()); 25793 assert(ex == "********+0x9.32c05a44p+27"); 25794 assert(ios.width() == 0); 25795 } 25796 ios.width(25); 25797 internal(ios); 25798 { 25799 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25800 std::string ex(str, iter.base()); 25801 assert(ex == "+********0x9.32c05a44p+27"); 25802 assert(ios.width() == 0); 25803 } 25804 } 25805 ios.imbue(lg); 25806 { 25807 ios.width(0); 25808 { 25809 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25810 std::string ex(str, iter.base()); 25811 assert(ex == "+0x9;32c05a44p+27"); 25812 assert(ios.width() == 0); 25813 } 25814 ios.width(25); 25815 left(ios); 25816 { 25817 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25818 std::string ex(str, iter.base()); 25819 assert(ex == "+0x9;32c05a44p+27********"); 25820 assert(ios.width() == 0); 25821 } 25822 ios.width(25); 25823 right(ios); 25824 { 25825 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25826 std::string ex(str, iter.base()); 25827 assert(ex == "********+0x9;32c05a44p+27"); 25828 assert(ios.width() == 0); 25829 } 25830 ios.width(25); 25831 internal(ios); 25832 { 25833 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25834 std::string ex(str, iter.base()); 25835 assert(ex == "+********0x9;32c05a44p+27"); 25836 assert(ios.width() == 0); 25837 } 25838 } 25839 } 25840 showpoint(ios); 25841 { 25842 ios.imbue(lc); 25843 { 25844 ios.width(0); 25845 { 25846 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25847 std::string ex(str, iter.base()); 25848 assert(ex == "+0x9.32c05a44p+27"); 25849 assert(ios.width() == 0); 25850 } 25851 ios.width(25); 25852 left(ios); 25853 { 25854 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25855 std::string ex(str, iter.base()); 25856 assert(ex == "+0x9.32c05a44p+27********"); 25857 assert(ios.width() == 0); 25858 } 25859 ios.width(25); 25860 right(ios); 25861 { 25862 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25863 std::string ex(str, iter.base()); 25864 assert(ex == "********+0x9.32c05a44p+27"); 25865 assert(ios.width() == 0); 25866 } 25867 ios.width(25); 25868 internal(ios); 25869 { 25870 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25871 std::string ex(str, iter.base()); 25872 assert(ex == "+********0x9.32c05a44p+27"); 25873 assert(ios.width() == 0); 25874 } 25875 } 25876 ios.imbue(lg); 25877 { 25878 ios.width(0); 25879 { 25880 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25881 std::string ex(str, iter.base()); 25882 assert(ex == "+0x9;32c05a44p+27"); 25883 assert(ios.width() == 0); 25884 } 25885 ios.width(25); 25886 left(ios); 25887 { 25888 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25889 std::string ex(str, iter.base()); 25890 assert(ex == "+0x9;32c05a44p+27********"); 25891 assert(ios.width() == 0); 25892 } 25893 ios.width(25); 25894 right(ios); 25895 { 25896 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25897 std::string ex(str, iter.base()); 25898 assert(ex == "********+0x9;32c05a44p+27"); 25899 assert(ios.width() == 0); 25900 } 25901 ios.width(25); 25902 internal(ios); 25903 { 25904 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25905 std::string ex(str, iter.base()); 25906 assert(ex == "+********0x9;32c05a44p+27"); 25907 assert(ios.width() == 0); 25908 } 25909 } 25910 } 25911 } 25912 } 25913 uppercase(ios); 25914 { 25915 noshowpos(ios); 25916 { 25917 noshowpoint(ios); 25918 { 25919 ios.imbue(lc); 25920 { 25921 ios.width(0); 25922 { 25923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25924 std::string ex(str, iter.base()); 25925 assert(ex == "0X9.32C05A44P+27"); 25926 assert(ios.width() == 0); 25927 } 25928 ios.width(25); 25929 left(ios); 25930 { 25931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25932 std::string ex(str, iter.base()); 25933 assert(ex == "0X9.32C05A44P+27*********"); 25934 assert(ios.width() == 0); 25935 } 25936 ios.width(25); 25937 right(ios); 25938 { 25939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25940 std::string ex(str, iter.base()); 25941 assert(ex == "*********0X9.32C05A44P+27"); 25942 assert(ios.width() == 0); 25943 } 25944 ios.width(25); 25945 internal(ios); 25946 { 25947 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25948 std::string ex(str, iter.base()); 25949 assert(ex == "0X*********9.32C05A44P+27"); 25950 assert(ios.width() == 0); 25951 } 25952 } 25953 ios.imbue(lg); 25954 { 25955 ios.width(0); 25956 { 25957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25958 std::string ex(str, iter.base()); 25959 assert(ex == "0X9;32C05A44P+27"); 25960 assert(ios.width() == 0); 25961 } 25962 ios.width(25); 25963 left(ios); 25964 { 25965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25966 std::string ex(str, iter.base()); 25967 assert(ex == "0X9;32C05A44P+27*********"); 25968 assert(ios.width() == 0); 25969 } 25970 ios.width(25); 25971 right(ios); 25972 { 25973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25974 std::string ex(str, iter.base()); 25975 assert(ex == "*********0X9;32C05A44P+27"); 25976 assert(ios.width() == 0); 25977 } 25978 ios.width(25); 25979 internal(ios); 25980 { 25981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25982 std::string ex(str, iter.base()); 25983 assert(ex == "0X*********9;32C05A44P+27"); 25984 assert(ios.width() == 0); 25985 } 25986 } 25987 } 25988 showpoint(ios); 25989 { 25990 ios.imbue(lc); 25991 { 25992 ios.width(0); 25993 { 25994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 25995 std::string ex(str, iter.base()); 25996 assert(ex == "0X9.32C05A44P+27"); 25997 assert(ios.width() == 0); 25998 } 25999 ios.width(25); 26000 left(ios); 26001 { 26002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26003 std::string ex(str, iter.base()); 26004 assert(ex == "0X9.32C05A44P+27*********"); 26005 assert(ios.width() == 0); 26006 } 26007 ios.width(25); 26008 right(ios); 26009 { 26010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26011 std::string ex(str, iter.base()); 26012 assert(ex == "*********0X9.32C05A44P+27"); 26013 assert(ios.width() == 0); 26014 } 26015 ios.width(25); 26016 internal(ios); 26017 { 26018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26019 std::string ex(str, iter.base()); 26020 assert(ex == "0X*********9.32C05A44P+27"); 26021 assert(ios.width() == 0); 26022 } 26023 } 26024 ios.imbue(lg); 26025 { 26026 ios.width(0); 26027 { 26028 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26029 std::string ex(str, iter.base()); 26030 assert(ex == "0X9;32C05A44P+27"); 26031 assert(ios.width() == 0); 26032 } 26033 ios.width(25); 26034 left(ios); 26035 { 26036 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26037 std::string ex(str, iter.base()); 26038 assert(ex == "0X9;32C05A44P+27*********"); 26039 assert(ios.width() == 0); 26040 } 26041 ios.width(25); 26042 right(ios); 26043 { 26044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26045 std::string ex(str, iter.base()); 26046 assert(ex == "*********0X9;32C05A44P+27"); 26047 assert(ios.width() == 0); 26048 } 26049 ios.width(25); 26050 internal(ios); 26051 { 26052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26053 std::string ex(str, iter.base()); 26054 assert(ex == "0X*********9;32C05A44P+27"); 26055 assert(ios.width() == 0); 26056 } 26057 } 26058 } 26059 } 26060 showpos(ios); 26061 { 26062 noshowpoint(ios); 26063 { 26064 ios.imbue(lc); 26065 { 26066 ios.width(0); 26067 { 26068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26069 std::string ex(str, iter.base()); 26070 assert(ex == "+0X9.32C05A44P+27"); 26071 assert(ios.width() == 0); 26072 } 26073 ios.width(25); 26074 left(ios); 26075 { 26076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26077 std::string ex(str, iter.base()); 26078 assert(ex == "+0X9.32C05A44P+27********"); 26079 assert(ios.width() == 0); 26080 } 26081 ios.width(25); 26082 right(ios); 26083 { 26084 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26085 std::string ex(str, iter.base()); 26086 assert(ex == "********+0X9.32C05A44P+27"); 26087 assert(ios.width() == 0); 26088 } 26089 ios.width(25); 26090 internal(ios); 26091 { 26092 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26093 std::string ex(str, iter.base()); 26094 assert(ex == "+********0X9.32C05A44P+27"); 26095 assert(ios.width() == 0); 26096 } 26097 } 26098 ios.imbue(lg); 26099 { 26100 ios.width(0); 26101 { 26102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26103 std::string ex(str, iter.base()); 26104 assert(ex == "+0X9;32C05A44P+27"); 26105 assert(ios.width() == 0); 26106 } 26107 ios.width(25); 26108 left(ios); 26109 { 26110 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26111 std::string ex(str, iter.base()); 26112 assert(ex == "+0X9;32C05A44P+27********"); 26113 assert(ios.width() == 0); 26114 } 26115 ios.width(25); 26116 right(ios); 26117 { 26118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26119 std::string ex(str, iter.base()); 26120 assert(ex == "********+0X9;32C05A44P+27"); 26121 assert(ios.width() == 0); 26122 } 26123 ios.width(25); 26124 internal(ios); 26125 { 26126 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26127 std::string ex(str, iter.base()); 26128 assert(ex == "+********0X9;32C05A44P+27"); 26129 assert(ios.width() == 0); 26130 } 26131 } 26132 } 26133 showpoint(ios); 26134 { 26135 ios.imbue(lc); 26136 { 26137 ios.width(0); 26138 { 26139 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26140 std::string ex(str, iter.base()); 26141 assert(ex == "+0X9.32C05A44P+27"); 26142 assert(ios.width() == 0); 26143 } 26144 ios.width(25); 26145 left(ios); 26146 { 26147 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26148 std::string ex(str, iter.base()); 26149 assert(ex == "+0X9.32C05A44P+27********"); 26150 assert(ios.width() == 0); 26151 } 26152 ios.width(25); 26153 right(ios); 26154 { 26155 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26156 std::string ex(str, iter.base()); 26157 assert(ex == "********+0X9.32C05A44P+27"); 26158 assert(ios.width() == 0); 26159 } 26160 ios.width(25); 26161 internal(ios); 26162 { 26163 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26164 std::string ex(str, iter.base()); 26165 assert(ex == "+********0X9.32C05A44P+27"); 26166 assert(ios.width() == 0); 26167 } 26168 } 26169 ios.imbue(lg); 26170 { 26171 ios.width(0); 26172 { 26173 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26174 std::string ex(str, iter.base()); 26175 assert(ex == "+0X9;32C05A44P+27"); 26176 assert(ios.width() == 0); 26177 } 26178 ios.width(25); 26179 left(ios); 26180 { 26181 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26182 std::string ex(str, iter.base()); 26183 assert(ex == "+0X9;32C05A44P+27********"); 26184 assert(ios.width() == 0); 26185 } 26186 ios.width(25); 26187 right(ios); 26188 { 26189 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26190 std::string ex(str, iter.base()); 26191 assert(ex == "********+0X9;32C05A44P+27"); 26192 assert(ios.width() == 0); 26193 } 26194 ios.width(25); 26195 internal(ios); 26196 { 26197 iter = f.put(output_iterator<char*>(str), ios, '*', v); 26198 std::string ex(str, iter.base()); 26199 assert(ex == "+********0X9;32C05A44P+27"); 26200 assert(ios.width() == 0); 26201 } 26202 } 26203 } 26204 } 26205 } 26206 } 26207 } 26208 } 26209 #endif 26210 } 26211 26212 int main() 26213 { 26214 test1(); 26215 test2(); 26216 test3(); 26217 test4(); 26218 test5(); 26219 test6(); 26220 test7(); 26221 test8(); 26222 test9(); 26223 test10(); 26224 test11(); 26225 test12(); 26226 output_iterator<char*> iter; 26227 std::locale lc = std::locale::classic(); 26228 std::locale lg(lc, new my_numpunct); 26229 const my_facet f(1); 26230 { 26231 long double v = -INFINITY; ((void)v); 26232 } 26233 { 26234 long double v = std::nan(""); ((void)v); 26235 } 26236 26237 { 26238 long double v = +0.; ((void)v); 26239 } 26240 { 26241 long double v = -INFINITY; ((void)v); 26242 } 26243 { 26244 long double v = std::nan(""); ((void)v); 26245 } 26246 { 26247 long double v = -INFINITY; ((void)v); 26248 } 26249 { 26250 long double v = std::nan(""); ((void)v); 26251 } 26252 } 26253