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 // <locale> 11 12 // class num_put<charT, OutputIterator> 13 14 // iter_type put(iter_type s, ios_base& iob, char_type fill, double v) const; 15 16 // TODO(EricWF): This test takes 40+ minutes to build with Clang 3.8 under ASAN or MSAN. 17 // UNSUPPORTED: asan, msan 18 19 #include <locale> 20 #include <ios> 21 #include <cassert> 22 #include <streambuf> 23 #include <cmath> 24 #include "test_iterators.h" 25 26 typedef std::num_put<char, output_iterator<char*> > F; 27 28 class my_facet 29 : public F 30 { 31 public: 32 explicit my_facet(std::size_t refs = 0) 33 : F(refs) {} 34 }; 35 36 class my_numpunct 37 : public std::numpunct<char> 38 { 39 public: 40 my_numpunct() : std::numpunct<char>() {} 41 42 protected: 43 virtual char_type do_decimal_point() const {return ';';} 44 virtual char_type do_thousands_sep() const {return '_';} 45 virtual std::string do_grouping() const {return std::string("\1\2\3");} 46 }; 47 48 void test1() 49 { 50 char str[200]; 51 output_iterator<char*> iter; 52 std::locale lc = std::locale::classic(); 53 std::locale lg(lc, new my_numpunct); 54 const my_facet f(1); 55 { 56 double v = +0.; 57 std::ios ios(0); 58 // %g 59 { 60 ios.precision(0); 61 { 62 nouppercase(ios); 63 { 64 noshowpos(ios); 65 { 66 noshowpoint(ios); 67 { 68 ios.imbue(lc); 69 { 70 ios.width(0); 71 { 72 iter = f.put(output_iterator<char*>(str), ios, '*', v); 73 std::string ex(str, iter.base()); 74 assert(ex == "0"); 75 assert(ios.width() == 0); 76 } 77 ios.width(25); 78 left(ios); 79 { 80 iter = f.put(output_iterator<char*>(str), ios, '*', v); 81 std::string ex(str, iter.base()); 82 assert(ex == "0************************"); 83 assert(ios.width() == 0); 84 } 85 ios.width(25); 86 right(ios); 87 { 88 iter = f.put(output_iterator<char*>(str), ios, '*', v); 89 std::string ex(str, iter.base()); 90 assert(ex == "************************0"); 91 assert(ios.width() == 0); 92 } 93 ios.width(25); 94 internal(ios); 95 { 96 iter = f.put(output_iterator<char*>(str), ios, '*', v); 97 std::string ex(str, iter.base()); 98 assert(ex == "************************0"); 99 assert(ios.width() == 0); 100 } 101 } 102 ios.imbue(lg); 103 { 104 ios.width(0); 105 { 106 iter = f.put(output_iterator<char*>(str), ios, '*', v); 107 std::string ex(str, iter.base()); 108 assert(ex == "0"); 109 assert(ios.width() == 0); 110 } 111 ios.width(25); 112 left(ios); 113 { 114 iter = f.put(output_iterator<char*>(str), ios, '*', v); 115 std::string ex(str, iter.base()); 116 assert(ex == "0************************"); 117 assert(ios.width() == 0); 118 } 119 ios.width(25); 120 right(ios); 121 { 122 iter = f.put(output_iterator<char*>(str), ios, '*', v); 123 std::string ex(str, iter.base()); 124 assert(ex == "************************0"); 125 assert(ios.width() == 0); 126 } 127 ios.width(25); 128 internal(ios); 129 { 130 iter = f.put(output_iterator<char*>(str), ios, '*', v); 131 std::string ex(str, iter.base()); 132 assert(ex == "************************0"); 133 assert(ios.width() == 0); 134 } 135 } 136 } 137 showpoint(ios); 138 { 139 ios.imbue(lc); 140 { 141 ios.width(0); 142 { 143 iter = f.put(output_iterator<char*>(str), ios, '*', v); 144 std::string ex(str, iter.base()); 145 assert(ex == "0."); 146 assert(ios.width() == 0); 147 } 148 ios.width(25); 149 left(ios); 150 { 151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 152 std::string ex(str, iter.base()); 153 assert(ex == "0.***********************"); 154 assert(ios.width() == 0); 155 } 156 ios.width(25); 157 right(ios); 158 { 159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 160 std::string ex(str, iter.base()); 161 assert(ex == "***********************0."); 162 assert(ios.width() == 0); 163 } 164 ios.width(25); 165 internal(ios); 166 { 167 iter = f.put(output_iterator<char*>(str), ios, '*', v); 168 std::string ex(str, iter.base()); 169 assert(ex == "***********************0."); 170 assert(ios.width() == 0); 171 } 172 } 173 ios.imbue(lg); 174 { 175 ios.width(0); 176 { 177 iter = f.put(output_iterator<char*>(str), ios, '*', v); 178 std::string ex(str, iter.base()); 179 assert(ex == "0;"); 180 assert(ios.width() == 0); 181 } 182 ios.width(25); 183 left(ios); 184 { 185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 186 std::string ex(str, iter.base()); 187 assert(ex == "0;***********************"); 188 assert(ios.width() == 0); 189 } 190 ios.width(25); 191 right(ios); 192 { 193 iter = f.put(output_iterator<char*>(str), ios, '*', v); 194 std::string ex(str, iter.base()); 195 assert(ex == "***********************0;"); 196 assert(ios.width() == 0); 197 } 198 ios.width(25); 199 internal(ios); 200 { 201 iter = f.put(output_iterator<char*>(str), ios, '*', v); 202 std::string ex(str, iter.base()); 203 assert(ex == "***********************0;"); 204 assert(ios.width() == 0); 205 } 206 } 207 } 208 } 209 showpos(ios); 210 { 211 noshowpoint(ios); 212 { 213 ios.imbue(lc); 214 { 215 ios.width(0); 216 { 217 iter = f.put(output_iterator<char*>(str), ios, '*', v); 218 std::string ex(str, iter.base()); 219 assert(ex == "+0"); 220 assert(ios.width() == 0); 221 } 222 ios.width(25); 223 left(ios); 224 { 225 iter = f.put(output_iterator<char*>(str), ios, '*', v); 226 std::string ex(str, iter.base()); 227 assert(ex == "+0***********************"); 228 assert(ios.width() == 0); 229 } 230 ios.width(25); 231 right(ios); 232 { 233 iter = f.put(output_iterator<char*>(str), ios, '*', v); 234 std::string ex(str, iter.base()); 235 assert(ex == "***********************+0"); 236 assert(ios.width() == 0); 237 } 238 ios.width(25); 239 internal(ios); 240 { 241 iter = f.put(output_iterator<char*>(str), ios, '*', v); 242 std::string ex(str, iter.base()); 243 assert(ex == "+***********************0"); 244 assert(ios.width() == 0); 245 } 246 } 247 ios.imbue(lg); 248 { 249 ios.width(0); 250 { 251 iter = f.put(output_iterator<char*>(str), ios, '*', v); 252 std::string ex(str, iter.base()); 253 assert(ex == "+0"); 254 assert(ios.width() == 0); 255 } 256 ios.width(25); 257 left(ios); 258 { 259 iter = f.put(output_iterator<char*>(str), ios, '*', v); 260 std::string ex(str, iter.base()); 261 assert(ex == "+0***********************"); 262 assert(ios.width() == 0); 263 } 264 ios.width(25); 265 right(ios); 266 { 267 iter = f.put(output_iterator<char*>(str), ios, '*', v); 268 std::string ex(str, iter.base()); 269 assert(ex == "***********************+0"); 270 assert(ios.width() == 0); 271 } 272 ios.width(25); 273 internal(ios); 274 { 275 iter = f.put(output_iterator<char*>(str), ios, '*', v); 276 std::string ex(str, iter.base()); 277 assert(ex == "+***********************0"); 278 assert(ios.width() == 0); 279 } 280 } 281 } 282 showpoint(ios); 283 { 284 ios.imbue(lc); 285 { 286 ios.width(0); 287 { 288 iter = f.put(output_iterator<char*>(str), ios, '*', v); 289 std::string ex(str, iter.base()); 290 assert(ex == "+0."); 291 assert(ios.width() == 0); 292 } 293 ios.width(25); 294 left(ios); 295 { 296 iter = f.put(output_iterator<char*>(str), ios, '*', v); 297 std::string ex(str, iter.base()); 298 assert(ex == "+0.**********************"); 299 assert(ios.width() == 0); 300 } 301 ios.width(25); 302 right(ios); 303 { 304 iter = f.put(output_iterator<char*>(str), ios, '*', v); 305 std::string ex(str, iter.base()); 306 assert(ex == "**********************+0."); 307 assert(ios.width() == 0); 308 } 309 ios.width(25); 310 internal(ios); 311 { 312 iter = f.put(output_iterator<char*>(str), ios, '*', v); 313 std::string ex(str, iter.base()); 314 assert(ex == "+**********************0."); 315 assert(ios.width() == 0); 316 } 317 } 318 ios.imbue(lg); 319 { 320 ios.width(0); 321 { 322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 323 std::string ex(str, iter.base()); 324 assert(ex == "+0;"); 325 assert(ios.width() == 0); 326 } 327 ios.width(25); 328 left(ios); 329 { 330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 331 std::string ex(str, iter.base()); 332 assert(ex == "+0;**********************"); 333 assert(ios.width() == 0); 334 } 335 ios.width(25); 336 right(ios); 337 { 338 iter = f.put(output_iterator<char*>(str), ios, '*', v); 339 std::string ex(str, iter.base()); 340 assert(ex == "**********************+0;"); 341 assert(ios.width() == 0); 342 } 343 ios.width(25); 344 internal(ios); 345 { 346 iter = f.put(output_iterator<char*>(str), ios, '*', v); 347 std::string ex(str, iter.base()); 348 assert(ex == "+**********************0;"); 349 assert(ios.width() == 0); 350 } 351 } 352 } 353 } 354 } 355 uppercase(ios); 356 { 357 noshowpos(ios); 358 { 359 noshowpoint(ios); 360 { 361 ios.imbue(lc); 362 { 363 ios.width(0); 364 { 365 iter = f.put(output_iterator<char*>(str), ios, '*', v); 366 std::string ex(str, iter.base()); 367 assert(ex == "0"); 368 assert(ios.width() == 0); 369 } 370 ios.width(25); 371 left(ios); 372 { 373 iter = f.put(output_iterator<char*>(str), ios, '*', v); 374 std::string ex(str, iter.base()); 375 assert(ex == "0************************"); 376 assert(ios.width() == 0); 377 } 378 ios.width(25); 379 right(ios); 380 { 381 iter = f.put(output_iterator<char*>(str), ios, '*', v); 382 std::string ex(str, iter.base()); 383 assert(ex == "************************0"); 384 assert(ios.width() == 0); 385 } 386 ios.width(25); 387 internal(ios); 388 { 389 iter = f.put(output_iterator<char*>(str), ios, '*', v); 390 std::string ex(str, iter.base()); 391 assert(ex == "************************0"); 392 assert(ios.width() == 0); 393 } 394 } 395 ios.imbue(lg); 396 { 397 ios.width(0); 398 { 399 iter = f.put(output_iterator<char*>(str), ios, '*', v); 400 std::string ex(str, iter.base()); 401 assert(ex == "0"); 402 assert(ios.width() == 0); 403 } 404 ios.width(25); 405 left(ios); 406 { 407 iter = f.put(output_iterator<char*>(str), ios, '*', v); 408 std::string ex(str, iter.base()); 409 assert(ex == "0************************"); 410 assert(ios.width() == 0); 411 } 412 ios.width(25); 413 right(ios); 414 { 415 iter = f.put(output_iterator<char*>(str), ios, '*', v); 416 std::string ex(str, iter.base()); 417 assert(ex == "************************0"); 418 assert(ios.width() == 0); 419 } 420 ios.width(25); 421 internal(ios); 422 { 423 iter = f.put(output_iterator<char*>(str), ios, '*', v); 424 std::string ex(str, iter.base()); 425 assert(ex == "************************0"); 426 assert(ios.width() == 0); 427 } 428 } 429 } 430 showpoint(ios); 431 { 432 ios.imbue(lc); 433 { 434 ios.width(0); 435 { 436 iter = f.put(output_iterator<char*>(str), ios, '*', v); 437 std::string ex(str, iter.base()); 438 assert(ex == "0."); 439 assert(ios.width() == 0); 440 } 441 ios.width(25); 442 left(ios); 443 { 444 iter = f.put(output_iterator<char*>(str), ios, '*', v); 445 std::string ex(str, iter.base()); 446 assert(ex == "0.***********************"); 447 assert(ios.width() == 0); 448 } 449 ios.width(25); 450 right(ios); 451 { 452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 453 std::string ex(str, iter.base()); 454 assert(ex == "***********************0."); 455 assert(ios.width() == 0); 456 } 457 ios.width(25); 458 internal(ios); 459 { 460 iter = f.put(output_iterator<char*>(str), ios, '*', v); 461 std::string ex(str, iter.base()); 462 assert(ex == "***********************0."); 463 assert(ios.width() == 0); 464 } 465 } 466 ios.imbue(lg); 467 { 468 ios.width(0); 469 { 470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 471 std::string ex(str, iter.base()); 472 assert(ex == "0;"); 473 assert(ios.width() == 0); 474 } 475 ios.width(25); 476 left(ios); 477 { 478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 479 std::string ex(str, iter.base()); 480 assert(ex == "0;***********************"); 481 assert(ios.width() == 0); 482 } 483 ios.width(25); 484 right(ios); 485 { 486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 487 std::string ex(str, iter.base()); 488 assert(ex == "***********************0;"); 489 assert(ios.width() == 0); 490 } 491 ios.width(25); 492 internal(ios); 493 { 494 iter = f.put(output_iterator<char*>(str), ios, '*', v); 495 std::string ex(str, iter.base()); 496 assert(ex == "***********************0;"); 497 assert(ios.width() == 0); 498 } 499 } 500 } 501 } 502 showpos(ios); 503 { 504 noshowpoint(ios); 505 { 506 ios.imbue(lc); 507 { 508 ios.width(0); 509 { 510 iter = f.put(output_iterator<char*>(str), ios, '*', v); 511 std::string ex(str, iter.base()); 512 assert(ex == "+0"); 513 assert(ios.width() == 0); 514 } 515 ios.width(25); 516 left(ios); 517 { 518 iter = f.put(output_iterator<char*>(str), ios, '*', v); 519 std::string ex(str, iter.base()); 520 assert(ex == "+0***********************"); 521 assert(ios.width() == 0); 522 } 523 ios.width(25); 524 right(ios); 525 { 526 iter = f.put(output_iterator<char*>(str), ios, '*', v); 527 std::string ex(str, iter.base()); 528 assert(ex == "***********************+0"); 529 assert(ios.width() == 0); 530 } 531 ios.width(25); 532 internal(ios); 533 { 534 iter = f.put(output_iterator<char*>(str), ios, '*', v); 535 std::string ex(str, iter.base()); 536 assert(ex == "+***********************0"); 537 assert(ios.width() == 0); 538 } 539 } 540 ios.imbue(lg); 541 { 542 ios.width(0); 543 { 544 iter = f.put(output_iterator<char*>(str), ios, '*', v); 545 std::string ex(str, iter.base()); 546 assert(ex == "+0"); 547 assert(ios.width() == 0); 548 } 549 ios.width(25); 550 left(ios); 551 { 552 iter = f.put(output_iterator<char*>(str), ios, '*', v); 553 std::string ex(str, iter.base()); 554 assert(ex == "+0***********************"); 555 assert(ios.width() == 0); 556 } 557 ios.width(25); 558 right(ios); 559 { 560 iter = f.put(output_iterator<char*>(str), ios, '*', v); 561 std::string ex(str, iter.base()); 562 assert(ex == "***********************+0"); 563 assert(ios.width() == 0); 564 } 565 ios.width(25); 566 internal(ios); 567 { 568 iter = f.put(output_iterator<char*>(str), ios, '*', v); 569 std::string ex(str, iter.base()); 570 assert(ex == "+***********************0"); 571 assert(ios.width() == 0); 572 } 573 } 574 } 575 showpoint(ios); 576 { 577 ios.imbue(lc); 578 { 579 ios.width(0); 580 { 581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 582 std::string ex(str, iter.base()); 583 assert(ex == "+0."); 584 assert(ios.width() == 0); 585 } 586 ios.width(25); 587 left(ios); 588 { 589 iter = f.put(output_iterator<char*>(str), ios, '*', v); 590 std::string ex(str, iter.base()); 591 assert(ex == "+0.**********************"); 592 assert(ios.width() == 0); 593 } 594 ios.width(25); 595 right(ios); 596 { 597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 598 std::string ex(str, iter.base()); 599 assert(ex == "**********************+0."); 600 assert(ios.width() == 0); 601 } 602 ios.width(25); 603 internal(ios); 604 { 605 iter = f.put(output_iterator<char*>(str), ios, '*', v); 606 std::string ex(str, iter.base()); 607 assert(ex == "+**********************0."); 608 assert(ios.width() == 0); 609 } 610 } 611 ios.imbue(lg); 612 { 613 ios.width(0); 614 { 615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 616 std::string ex(str, iter.base()); 617 assert(ex == "+0;"); 618 assert(ios.width() == 0); 619 } 620 ios.width(25); 621 left(ios); 622 { 623 iter = f.put(output_iterator<char*>(str), ios, '*', v); 624 std::string ex(str, iter.base()); 625 assert(ex == "+0;**********************"); 626 assert(ios.width() == 0); 627 } 628 ios.width(25); 629 right(ios); 630 { 631 iter = f.put(output_iterator<char*>(str), ios, '*', v); 632 std::string ex(str, iter.base()); 633 assert(ex == "**********************+0;"); 634 assert(ios.width() == 0); 635 } 636 ios.width(25); 637 internal(ios); 638 { 639 iter = f.put(output_iterator<char*>(str), ios, '*', v); 640 std::string ex(str, iter.base()); 641 assert(ex == "+**********************0;"); 642 assert(ios.width() == 0); 643 } 644 } 645 } 646 } 647 } 648 } 649 ios.precision(1); 650 { 651 nouppercase(ios); 652 { 653 noshowpos(ios); 654 { 655 noshowpoint(ios); 656 { 657 ios.imbue(lc); 658 { 659 ios.width(0); 660 { 661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 662 std::string ex(str, iter.base()); 663 assert(ex == "0"); 664 assert(ios.width() == 0); 665 } 666 ios.width(25); 667 left(ios); 668 { 669 iter = f.put(output_iterator<char*>(str), ios, '*', v); 670 std::string ex(str, iter.base()); 671 assert(ex == "0************************"); 672 assert(ios.width() == 0); 673 } 674 ios.width(25); 675 right(ios); 676 { 677 iter = f.put(output_iterator<char*>(str), ios, '*', v); 678 std::string ex(str, iter.base()); 679 assert(ex == "************************0"); 680 assert(ios.width() == 0); 681 } 682 ios.width(25); 683 internal(ios); 684 { 685 iter = f.put(output_iterator<char*>(str), ios, '*', v); 686 std::string ex(str, iter.base()); 687 assert(ex == "************************0"); 688 assert(ios.width() == 0); 689 } 690 } 691 ios.imbue(lg); 692 { 693 ios.width(0); 694 { 695 iter = f.put(output_iterator<char*>(str), ios, '*', v); 696 std::string ex(str, iter.base()); 697 assert(ex == "0"); 698 assert(ios.width() == 0); 699 } 700 ios.width(25); 701 left(ios); 702 { 703 iter = f.put(output_iterator<char*>(str), ios, '*', v); 704 std::string ex(str, iter.base()); 705 assert(ex == "0************************"); 706 assert(ios.width() == 0); 707 } 708 ios.width(25); 709 right(ios); 710 { 711 iter = f.put(output_iterator<char*>(str), ios, '*', v); 712 std::string ex(str, iter.base()); 713 assert(ex == "************************0"); 714 assert(ios.width() == 0); 715 } 716 ios.width(25); 717 internal(ios); 718 { 719 iter = f.put(output_iterator<char*>(str), ios, '*', v); 720 std::string ex(str, iter.base()); 721 assert(ex == "************************0"); 722 assert(ios.width() == 0); 723 } 724 } 725 } 726 showpoint(ios); 727 { 728 ios.imbue(lc); 729 { 730 ios.width(0); 731 { 732 iter = f.put(output_iterator<char*>(str), ios, '*', v); 733 std::string ex(str, iter.base()); 734 assert(ex == "0."); 735 assert(ios.width() == 0); 736 } 737 ios.width(25); 738 left(ios); 739 { 740 iter = f.put(output_iterator<char*>(str), ios, '*', v); 741 std::string ex(str, iter.base()); 742 assert(ex == "0.***********************"); 743 assert(ios.width() == 0); 744 } 745 ios.width(25); 746 right(ios); 747 { 748 iter = f.put(output_iterator<char*>(str), ios, '*', v); 749 std::string ex(str, iter.base()); 750 assert(ex == "***********************0."); 751 assert(ios.width() == 0); 752 } 753 ios.width(25); 754 internal(ios); 755 { 756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 757 std::string ex(str, iter.base()); 758 assert(ex == "***********************0."); 759 assert(ios.width() == 0); 760 } 761 } 762 ios.imbue(lg); 763 { 764 ios.width(0); 765 { 766 iter = f.put(output_iterator<char*>(str), ios, '*', v); 767 std::string ex(str, iter.base()); 768 assert(ex == "0;"); 769 assert(ios.width() == 0); 770 } 771 ios.width(25); 772 left(ios); 773 { 774 iter = f.put(output_iterator<char*>(str), ios, '*', v); 775 std::string ex(str, iter.base()); 776 assert(ex == "0;***********************"); 777 assert(ios.width() == 0); 778 } 779 ios.width(25); 780 right(ios); 781 { 782 iter = f.put(output_iterator<char*>(str), ios, '*', v); 783 std::string ex(str, iter.base()); 784 assert(ex == "***********************0;"); 785 assert(ios.width() == 0); 786 } 787 ios.width(25); 788 internal(ios); 789 { 790 iter = f.put(output_iterator<char*>(str), ios, '*', v); 791 std::string ex(str, iter.base()); 792 assert(ex == "***********************0;"); 793 assert(ios.width() == 0); 794 } 795 } 796 } 797 } 798 showpos(ios); 799 { 800 noshowpoint(ios); 801 { 802 ios.imbue(lc); 803 { 804 ios.width(0); 805 { 806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 807 std::string ex(str, iter.base()); 808 assert(ex == "+0"); 809 assert(ios.width() == 0); 810 } 811 ios.width(25); 812 left(ios); 813 { 814 iter = f.put(output_iterator<char*>(str), ios, '*', v); 815 std::string ex(str, iter.base()); 816 assert(ex == "+0***********************"); 817 assert(ios.width() == 0); 818 } 819 ios.width(25); 820 right(ios); 821 { 822 iter = f.put(output_iterator<char*>(str), ios, '*', v); 823 std::string ex(str, iter.base()); 824 assert(ex == "***********************+0"); 825 assert(ios.width() == 0); 826 } 827 ios.width(25); 828 internal(ios); 829 { 830 iter = f.put(output_iterator<char*>(str), ios, '*', v); 831 std::string ex(str, iter.base()); 832 assert(ex == "+***********************0"); 833 assert(ios.width() == 0); 834 } 835 } 836 ios.imbue(lg); 837 { 838 ios.width(0); 839 { 840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 841 std::string ex(str, iter.base()); 842 assert(ex == "+0"); 843 assert(ios.width() == 0); 844 } 845 ios.width(25); 846 left(ios); 847 { 848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 849 std::string ex(str, iter.base()); 850 assert(ex == "+0***********************"); 851 assert(ios.width() == 0); 852 } 853 ios.width(25); 854 right(ios); 855 { 856 iter = f.put(output_iterator<char*>(str), ios, '*', v); 857 std::string ex(str, iter.base()); 858 assert(ex == "***********************+0"); 859 assert(ios.width() == 0); 860 } 861 ios.width(25); 862 internal(ios); 863 { 864 iter = f.put(output_iterator<char*>(str), ios, '*', v); 865 std::string ex(str, iter.base()); 866 assert(ex == "+***********************0"); 867 assert(ios.width() == 0); 868 } 869 } 870 } 871 showpoint(ios); 872 { 873 ios.imbue(lc); 874 { 875 ios.width(0); 876 { 877 iter = f.put(output_iterator<char*>(str), ios, '*', v); 878 std::string ex(str, iter.base()); 879 assert(ex == "+0."); 880 assert(ios.width() == 0); 881 } 882 ios.width(25); 883 left(ios); 884 { 885 iter = f.put(output_iterator<char*>(str), ios, '*', v); 886 std::string ex(str, iter.base()); 887 assert(ex == "+0.**********************"); 888 assert(ios.width() == 0); 889 } 890 ios.width(25); 891 right(ios); 892 { 893 iter = f.put(output_iterator<char*>(str), ios, '*', v); 894 std::string ex(str, iter.base()); 895 assert(ex == "**********************+0."); 896 assert(ios.width() == 0); 897 } 898 ios.width(25); 899 internal(ios); 900 { 901 iter = f.put(output_iterator<char*>(str), ios, '*', v); 902 std::string ex(str, iter.base()); 903 assert(ex == "+**********************0."); 904 assert(ios.width() == 0); 905 } 906 } 907 ios.imbue(lg); 908 { 909 ios.width(0); 910 { 911 iter = f.put(output_iterator<char*>(str), ios, '*', v); 912 std::string ex(str, iter.base()); 913 assert(ex == "+0;"); 914 assert(ios.width() == 0); 915 } 916 ios.width(25); 917 left(ios); 918 { 919 iter = f.put(output_iterator<char*>(str), ios, '*', v); 920 std::string ex(str, iter.base()); 921 assert(ex == "+0;**********************"); 922 assert(ios.width() == 0); 923 } 924 ios.width(25); 925 right(ios); 926 { 927 iter = f.put(output_iterator<char*>(str), ios, '*', v); 928 std::string ex(str, iter.base()); 929 assert(ex == "**********************+0;"); 930 assert(ios.width() == 0); 931 } 932 ios.width(25); 933 internal(ios); 934 { 935 iter = f.put(output_iterator<char*>(str), ios, '*', v); 936 std::string ex(str, iter.base()); 937 assert(ex == "+**********************0;"); 938 assert(ios.width() == 0); 939 } 940 } 941 } 942 } 943 } 944 uppercase(ios); 945 { 946 noshowpos(ios); 947 { 948 noshowpoint(ios); 949 { 950 ios.imbue(lc); 951 { 952 ios.width(0); 953 { 954 iter = f.put(output_iterator<char*>(str), ios, '*', v); 955 std::string ex(str, iter.base()); 956 assert(ex == "0"); 957 assert(ios.width() == 0); 958 } 959 ios.width(25); 960 left(ios); 961 { 962 iter = f.put(output_iterator<char*>(str), ios, '*', v); 963 std::string ex(str, iter.base()); 964 assert(ex == "0************************"); 965 assert(ios.width() == 0); 966 } 967 ios.width(25); 968 right(ios); 969 { 970 iter = f.put(output_iterator<char*>(str), ios, '*', v); 971 std::string ex(str, iter.base()); 972 assert(ex == "************************0"); 973 assert(ios.width() == 0); 974 } 975 ios.width(25); 976 internal(ios); 977 { 978 iter = f.put(output_iterator<char*>(str), ios, '*', v); 979 std::string ex(str, iter.base()); 980 assert(ex == "************************0"); 981 assert(ios.width() == 0); 982 } 983 } 984 ios.imbue(lg); 985 { 986 ios.width(0); 987 { 988 iter = f.put(output_iterator<char*>(str), ios, '*', v); 989 std::string ex(str, iter.base()); 990 assert(ex == "0"); 991 assert(ios.width() == 0); 992 } 993 ios.width(25); 994 left(ios); 995 { 996 iter = f.put(output_iterator<char*>(str), ios, '*', v); 997 std::string ex(str, iter.base()); 998 assert(ex == "0************************"); 999 assert(ios.width() == 0); 1000 } 1001 ios.width(25); 1002 right(ios); 1003 { 1004 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1005 std::string ex(str, iter.base()); 1006 assert(ex == "************************0"); 1007 assert(ios.width() == 0); 1008 } 1009 ios.width(25); 1010 internal(ios); 1011 { 1012 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1013 std::string ex(str, iter.base()); 1014 assert(ex == "************************0"); 1015 assert(ios.width() == 0); 1016 } 1017 } 1018 } 1019 showpoint(ios); 1020 { 1021 ios.imbue(lc); 1022 { 1023 ios.width(0); 1024 { 1025 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1026 std::string ex(str, iter.base()); 1027 assert(ex == "0."); 1028 assert(ios.width() == 0); 1029 } 1030 ios.width(25); 1031 left(ios); 1032 { 1033 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1034 std::string ex(str, iter.base()); 1035 assert(ex == "0.***********************"); 1036 assert(ios.width() == 0); 1037 } 1038 ios.width(25); 1039 right(ios); 1040 { 1041 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1042 std::string ex(str, iter.base()); 1043 assert(ex == "***********************0."); 1044 assert(ios.width() == 0); 1045 } 1046 ios.width(25); 1047 internal(ios); 1048 { 1049 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1050 std::string ex(str, iter.base()); 1051 assert(ex == "***********************0."); 1052 assert(ios.width() == 0); 1053 } 1054 } 1055 ios.imbue(lg); 1056 { 1057 ios.width(0); 1058 { 1059 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1060 std::string ex(str, iter.base()); 1061 assert(ex == "0;"); 1062 assert(ios.width() == 0); 1063 } 1064 ios.width(25); 1065 left(ios); 1066 { 1067 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1068 std::string ex(str, iter.base()); 1069 assert(ex == "0;***********************"); 1070 assert(ios.width() == 0); 1071 } 1072 ios.width(25); 1073 right(ios); 1074 { 1075 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1076 std::string ex(str, iter.base()); 1077 assert(ex == "***********************0;"); 1078 assert(ios.width() == 0); 1079 } 1080 ios.width(25); 1081 internal(ios); 1082 { 1083 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1084 std::string ex(str, iter.base()); 1085 assert(ex == "***********************0;"); 1086 assert(ios.width() == 0); 1087 } 1088 } 1089 } 1090 } 1091 showpos(ios); 1092 { 1093 noshowpoint(ios); 1094 { 1095 ios.imbue(lc); 1096 { 1097 ios.width(0); 1098 { 1099 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1100 std::string ex(str, iter.base()); 1101 assert(ex == "+0"); 1102 assert(ios.width() == 0); 1103 } 1104 ios.width(25); 1105 left(ios); 1106 { 1107 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1108 std::string ex(str, iter.base()); 1109 assert(ex == "+0***********************"); 1110 assert(ios.width() == 0); 1111 } 1112 ios.width(25); 1113 right(ios); 1114 { 1115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1116 std::string ex(str, iter.base()); 1117 assert(ex == "***********************+0"); 1118 assert(ios.width() == 0); 1119 } 1120 ios.width(25); 1121 internal(ios); 1122 { 1123 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1124 std::string ex(str, iter.base()); 1125 assert(ex == "+***********************0"); 1126 assert(ios.width() == 0); 1127 } 1128 } 1129 ios.imbue(lg); 1130 { 1131 ios.width(0); 1132 { 1133 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1134 std::string ex(str, iter.base()); 1135 assert(ex == "+0"); 1136 assert(ios.width() == 0); 1137 } 1138 ios.width(25); 1139 left(ios); 1140 { 1141 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1142 std::string ex(str, iter.base()); 1143 assert(ex == "+0***********************"); 1144 assert(ios.width() == 0); 1145 } 1146 ios.width(25); 1147 right(ios); 1148 { 1149 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1150 std::string ex(str, iter.base()); 1151 assert(ex == "***********************+0"); 1152 assert(ios.width() == 0); 1153 } 1154 ios.width(25); 1155 internal(ios); 1156 { 1157 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1158 std::string ex(str, iter.base()); 1159 assert(ex == "+***********************0"); 1160 assert(ios.width() == 0); 1161 } 1162 } 1163 } 1164 showpoint(ios); 1165 { 1166 ios.imbue(lc); 1167 { 1168 ios.width(0); 1169 { 1170 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1171 std::string ex(str, iter.base()); 1172 assert(ex == "+0."); 1173 assert(ios.width() == 0); 1174 } 1175 ios.width(25); 1176 left(ios); 1177 { 1178 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1179 std::string ex(str, iter.base()); 1180 assert(ex == "+0.**********************"); 1181 assert(ios.width() == 0); 1182 } 1183 ios.width(25); 1184 right(ios); 1185 { 1186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1187 std::string ex(str, iter.base()); 1188 assert(ex == "**********************+0."); 1189 assert(ios.width() == 0); 1190 } 1191 ios.width(25); 1192 internal(ios); 1193 { 1194 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1195 std::string ex(str, iter.base()); 1196 assert(ex == "+**********************0."); 1197 assert(ios.width() == 0); 1198 } 1199 } 1200 ios.imbue(lg); 1201 { 1202 ios.width(0); 1203 { 1204 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1205 std::string ex(str, iter.base()); 1206 assert(ex == "+0;"); 1207 assert(ios.width() == 0); 1208 } 1209 ios.width(25); 1210 left(ios); 1211 { 1212 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1213 std::string ex(str, iter.base()); 1214 assert(ex == "+0;**********************"); 1215 assert(ios.width() == 0); 1216 } 1217 ios.width(25); 1218 right(ios); 1219 { 1220 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1221 std::string ex(str, iter.base()); 1222 assert(ex == "**********************+0;"); 1223 assert(ios.width() == 0); 1224 } 1225 ios.width(25); 1226 internal(ios); 1227 { 1228 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1229 std::string ex(str, iter.base()); 1230 assert(ex == "+**********************0;"); 1231 assert(ios.width() == 0); 1232 } 1233 } 1234 } 1235 } 1236 } 1237 } 1238 ios.precision(6); 1239 { 1240 nouppercase(ios); 1241 { 1242 noshowpos(ios); 1243 { 1244 noshowpoint(ios); 1245 { 1246 ios.imbue(lc); 1247 { 1248 ios.width(0); 1249 { 1250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1251 std::string ex(str, iter.base()); 1252 assert(ex == "0"); 1253 assert(ios.width() == 0); 1254 } 1255 ios.width(25); 1256 left(ios); 1257 { 1258 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1259 std::string ex(str, iter.base()); 1260 assert(ex == "0************************"); 1261 assert(ios.width() == 0); 1262 } 1263 ios.width(25); 1264 right(ios); 1265 { 1266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1267 std::string ex(str, iter.base()); 1268 assert(ex == "************************0"); 1269 assert(ios.width() == 0); 1270 } 1271 ios.width(25); 1272 internal(ios); 1273 { 1274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1275 std::string ex(str, iter.base()); 1276 assert(ex == "************************0"); 1277 assert(ios.width() == 0); 1278 } 1279 } 1280 ios.imbue(lg); 1281 { 1282 ios.width(0); 1283 { 1284 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1285 std::string ex(str, iter.base()); 1286 assert(ex == "0"); 1287 assert(ios.width() == 0); 1288 } 1289 ios.width(25); 1290 left(ios); 1291 { 1292 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1293 std::string ex(str, iter.base()); 1294 assert(ex == "0************************"); 1295 assert(ios.width() == 0); 1296 } 1297 ios.width(25); 1298 right(ios); 1299 { 1300 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1301 std::string ex(str, iter.base()); 1302 assert(ex == "************************0"); 1303 assert(ios.width() == 0); 1304 } 1305 ios.width(25); 1306 internal(ios); 1307 { 1308 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1309 std::string ex(str, iter.base()); 1310 assert(ex == "************************0"); 1311 assert(ios.width() == 0); 1312 } 1313 } 1314 } 1315 showpoint(ios); 1316 { 1317 ios.imbue(lc); 1318 { 1319 ios.width(0); 1320 { 1321 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1322 std::string ex(str, iter.base()); 1323 assert(ex == "0.00000"); 1324 assert(ios.width() == 0); 1325 } 1326 ios.width(25); 1327 left(ios); 1328 { 1329 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1330 std::string ex(str, iter.base()); 1331 assert(ex == "0.00000******************"); 1332 assert(ios.width() == 0); 1333 } 1334 ios.width(25); 1335 right(ios); 1336 { 1337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1338 std::string ex(str, iter.base()); 1339 assert(ex == "******************0.00000"); 1340 assert(ios.width() == 0); 1341 } 1342 ios.width(25); 1343 internal(ios); 1344 { 1345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1346 std::string ex(str, iter.base()); 1347 assert(ex == "******************0.00000"); 1348 assert(ios.width() == 0); 1349 } 1350 } 1351 ios.imbue(lg); 1352 { 1353 ios.width(0); 1354 { 1355 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1356 std::string ex(str, iter.base()); 1357 assert(ex == "0;00000"); 1358 assert(ios.width() == 0); 1359 } 1360 ios.width(25); 1361 left(ios); 1362 { 1363 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1364 std::string ex(str, iter.base()); 1365 assert(ex == "0;00000******************"); 1366 assert(ios.width() == 0); 1367 } 1368 ios.width(25); 1369 right(ios); 1370 { 1371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1372 std::string ex(str, iter.base()); 1373 assert(ex == "******************0;00000"); 1374 assert(ios.width() == 0); 1375 } 1376 ios.width(25); 1377 internal(ios); 1378 { 1379 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1380 std::string ex(str, iter.base()); 1381 assert(ex == "******************0;00000"); 1382 assert(ios.width() == 0); 1383 } 1384 } 1385 } 1386 } 1387 showpos(ios); 1388 { 1389 noshowpoint(ios); 1390 { 1391 ios.imbue(lc); 1392 { 1393 ios.width(0); 1394 { 1395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1396 std::string ex(str, iter.base()); 1397 assert(ex == "+0"); 1398 assert(ios.width() == 0); 1399 } 1400 ios.width(25); 1401 left(ios); 1402 { 1403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1404 std::string ex(str, iter.base()); 1405 assert(ex == "+0***********************"); 1406 assert(ios.width() == 0); 1407 } 1408 ios.width(25); 1409 right(ios); 1410 { 1411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1412 std::string ex(str, iter.base()); 1413 assert(ex == "***********************+0"); 1414 assert(ios.width() == 0); 1415 } 1416 ios.width(25); 1417 internal(ios); 1418 { 1419 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1420 std::string ex(str, iter.base()); 1421 assert(ex == "+***********************0"); 1422 assert(ios.width() == 0); 1423 } 1424 } 1425 ios.imbue(lg); 1426 { 1427 ios.width(0); 1428 { 1429 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1430 std::string ex(str, iter.base()); 1431 assert(ex == "+0"); 1432 assert(ios.width() == 0); 1433 } 1434 ios.width(25); 1435 left(ios); 1436 { 1437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1438 std::string ex(str, iter.base()); 1439 assert(ex == "+0***********************"); 1440 assert(ios.width() == 0); 1441 } 1442 ios.width(25); 1443 right(ios); 1444 { 1445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1446 std::string ex(str, iter.base()); 1447 assert(ex == "***********************+0"); 1448 assert(ios.width() == 0); 1449 } 1450 ios.width(25); 1451 internal(ios); 1452 { 1453 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1454 std::string ex(str, iter.base()); 1455 assert(ex == "+***********************0"); 1456 assert(ios.width() == 0); 1457 } 1458 } 1459 } 1460 showpoint(ios); 1461 { 1462 ios.imbue(lc); 1463 { 1464 ios.width(0); 1465 { 1466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1467 std::string ex(str, iter.base()); 1468 assert(ex == "+0.00000"); 1469 assert(ios.width() == 0); 1470 } 1471 ios.width(25); 1472 left(ios); 1473 { 1474 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1475 std::string ex(str, iter.base()); 1476 assert(ex == "+0.00000*****************"); 1477 assert(ios.width() == 0); 1478 } 1479 ios.width(25); 1480 right(ios); 1481 { 1482 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1483 std::string ex(str, iter.base()); 1484 assert(ex == "*****************+0.00000"); 1485 assert(ios.width() == 0); 1486 } 1487 ios.width(25); 1488 internal(ios); 1489 { 1490 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1491 std::string ex(str, iter.base()); 1492 assert(ex == "+*****************0.00000"); 1493 assert(ios.width() == 0); 1494 } 1495 } 1496 ios.imbue(lg); 1497 { 1498 ios.width(0); 1499 { 1500 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1501 std::string ex(str, iter.base()); 1502 assert(ex == "+0;00000"); 1503 assert(ios.width() == 0); 1504 } 1505 ios.width(25); 1506 left(ios); 1507 { 1508 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1509 std::string ex(str, iter.base()); 1510 assert(ex == "+0;00000*****************"); 1511 assert(ios.width() == 0); 1512 } 1513 ios.width(25); 1514 right(ios); 1515 { 1516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1517 std::string ex(str, iter.base()); 1518 assert(ex == "*****************+0;00000"); 1519 assert(ios.width() == 0); 1520 } 1521 ios.width(25); 1522 internal(ios); 1523 { 1524 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1525 std::string ex(str, iter.base()); 1526 assert(ex == "+*****************0;00000"); 1527 assert(ios.width() == 0); 1528 } 1529 } 1530 } 1531 } 1532 } 1533 uppercase(ios); 1534 { 1535 noshowpos(ios); 1536 { 1537 noshowpoint(ios); 1538 { 1539 ios.imbue(lc); 1540 { 1541 ios.width(0); 1542 { 1543 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1544 std::string ex(str, iter.base()); 1545 assert(ex == "0"); 1546 assert(ios.width() == 0); 1547 } 1548 ios.width(25); 1549 left(ios); 1550 { 1551 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1552 std::string ex(str, iter.base()); 1553 assert(ex == "0************************"); 1554 assert(ios.width() == 0); 1555 } 1556 ios.width(25); 1557 right(ios); 1558 { 1559 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1560 std::string ex(str, iter.base()); 1561 assert(ex == "************************0"); 1562 assert(ios.width() == 0); 1563 } 1564 ios.width(25); 1565 internal(ios); 1566 { 1567 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1568 std::string ex(str, iter.base()); 1569 assert(ex == "************************0"); 1570 assert(ios.width() == 0); 1571 } 1572 } 1573 ios.imbue(lg); 1574 { 1575 ios.width(0); 1576 { 1577 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1578 std::string ex(str, iter.base()); 1579 assert(ex == "0"); 1580 assert(ios.width() == 0); 1581 } 1582 ios.width(25); 1583 left(ios); 1584 { 1585 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1586 std::string ex(str, iter.base()); 1587 assert(ex == "0************************"); 1588 assert(ios.width() == 0); 1589 } 1590 ios.width(25); 1591 right(ios); 1592 { 1593 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1594 std::string ex(str, iter.base()); 1595 assert(ex == "************************0"); 1596 assert(ios.width() == 0); 1597 } 1598 ios.width(25); 1599 internal(ios); 1600 { 1601 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1602 std::string ex(str, iter.base()); 1603 assert(ex == "************************0"); 1604 assert(ios.width() == 0); 1605 } 1606 } 1607 } 1608 showpoint(ios); 1609 { 1610 ios.imbue(lc); 1611 { 1612 ios.width(0); 1613 { 1614 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1615 std::string ex(str, iter.base()); 1616 assert(ex == "0.00000"); 1617 assert(ios.width() == 0); 1618 } 1619 ios.width(25); 1620 left(ios); 1621 { 1622 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1623 std::string ex(str, iter.base()); 1624 assert(ex == "0.00000******************"); 1625 assert(ios.width() == 0); 1626 } 1627 ios.width(25); 1628 right(ios); 1629 { 1630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1631 std::string ex(str, iter.base()); 1632 assert(ex == "******************0.00000"); 1633 assert(ios.width() == 0); 1634 } 1635 ios.width(25); 1636 internal(ios); 1637 { 1638 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1639 std::string ex(str, iter.base()); 1640 assert(ex == "******************0.00000"); 1641 assert(ios.width() == 0); 1642 } 1643 } 1644 ios.imbue(lg); 1645 { 1646 ios.width(0); 1647 { 1648 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1649 std::string ex(str, iter.base()); 1650 assert(ex == "0;00000"); 1651 assert(ios.width() == 0); 1652 } 1653 ios.width(25); 1654 left(ios); 1655 { 1656 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1657 std::string ex(str, iter.base()); 1658 assert(ex == "0;00000******************"); 1659 assert(ios.width() == 0); 1660 } 1661 ios.width(25); 1662 right(ios); 1663 { 1664 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1665 std::string ex(str, iter.base()); 1666 assert(ex == "******************0;00000"); 1667 assert(ios.width() == 0); 1668 } 1669 ios.width(25); 1670 internal(ios); 1671 { 1672 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1673 std::string ex(str, iter.base()); 1674 assert(ex == "******************0;00000"); 1675 assert(ios.width() == 0); 1676 } 1677 } 1678 } 1679 } 1680 showpos(ios); 1681 { 1682 noshowpoint(ios); 1683 { 1684 ios.imbue(lc); 1685 { 1686 ios.width(0); 1687 { 1688 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1689 std::string ex(str, iter.base()); 1690 assert(ex == "+0"); 1691 assert(ios.width() == 0); 1692 } 1693 ios.width(25); 1694 left(ios); 1695 { 1696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1697 std::string ex(str, iter.base()); 1698 assert(ex == "+0***********************"); 1699 assert(ios.width() == 0); 1700 } 1701 ios.width(25); 1702 right(ios); 1703 { 1704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1705 std::string ex(str, iter.base()); 1706 assert(ex == "***********************+0"); 1707 assert(ios.width() == 0); 1708 } 1709 ios.width(25); 1710 internal(ios); 1711 { 1712 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1713 std::string ex(str, iter.base()); 1714 assert(ex == "+***********************0"); 1715 assert(ios.width() == 0); 1716 } 1717 } 1718 ios.imbue(lg); 1719 { 1720 ios.width(0); 1721 { 1722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1723 std::string ex(str, iter.base()); 1724 assert(ex == "+0"); 1725 assert(ios.width() == 0); 1726 } 1727 ios.width(25); 1728 left(ios); 1729 { 1730 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1731 std::string ex(str, iter.base()); 1732 assert(ex == "+0***********************"); 1733 assert(ios.width() == 0); 1734 } 1735 ios.width(25); 1736 right(ios); 1737 { 1738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1739 std::string ex(str, iter.base()); 1740 assert(ex == "***********************+0"); 1741 assert(ios.width() == 0); 1742 } 1743 ios.width(25); 1744 internal(ios); 1745 { 1746 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1747 std::string ex(str, iter.base()); 1748 assert(ex == "+***********************0"); 1749 assert(ios.width() == 0); 1750 } 1751 } 1752 } 1753 showpoint(ios); 1754 { 1755 ios.imbue(lc); 1756 { 1757 ios.width(0); 1758 { 1759 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1760 std::string ex(str, iter.base()); 1761 assert(ex == "+0.00000"); 1762 assert(ios.width() == 0); 1763 } 1764 ios.width(25); 1765 left(ios); 1766 { 1767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1768 std::string ex(str, iter.base()); 1769 assert(ex == "+0.00000*****************"); 1770 assert(ios.width() == 0); 1771 } 1772 ios.width(25); 1773 right(ios); 1774 { 1775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1776 std::string ex(str, iter.base()); 1777 assert(ex == "*****************+0.00000"); 1778 assert(ios.width() == 0); 1779 } 1780 ios.width(25); 1781 internal(ios); 1782 { 1783 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1784 std::string ex(str, iter.base()); 1785 assert(ex == "+*****************0.00000"); 1786 assert(ios.width() == 0); 1787 } 1788 } 1789 ios.imbue(lg); 1790 { 1791 ios.width(0); 1792 { 1793 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1794 std::string ex(str, iter.base()); 1795 assert(ex == "+0;00000"); 1796 assert(ios.width() == 0); 1797 } 1798 ios.width(25); 1799 left(ios); 1800 { 1801 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1802 std::string ex(str, iter.base()); 1803 assert(ex == "+0;00000*****************"); 1804 assert(ios.width() == 0); 1805 } 1806 ios.width(25); 1807 right(ios); 1808 { 1809 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1810 std::string ex(str, iter.base()); 1811 assert(ex == "*****************+0;00000"); 1812 assert(ios.width() == 0); 1813 } 1814 ios.width(25); 1815 internal(ios); 1816 { 1817 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1818 std::string ex(str, iter.base()); 1819 assert(ex == "+*****************0;00000"); 1820 assert(ios.width() == 0); 1821 } 1822 } 1823 } 1824 } 1825 } 1826 } 1827 ios.precision(16); 1828 { 1829 nouppercase(ios); 1830 { 1831 noshowpos(ios); 1832 { 1833 noshowpoint(ios); 1834 { 1835 ios.imbue(lc); 1836 { 1837 ios.width(0); 1838 { 1839 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1840 std::string ex(str, iter.base()); 1841 assert(ex == "0"); 1842 assert(ios.width() == 0); 1843 } 1844 ios.width(25); 1845 left(ios); 1846 { 1847 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1848 std::string ex(str, iter.base()); 1849 assert(ex == "0************************"); 1850 assert(ios.width() == 0); 1851 } 1852 ios.width(25); 1853 right(ios); 1854 { 1855 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1856 std::string ex(str, iter.base()); 1857 assert(ex == "************************0"); 1858 assert(ios.width() == 0); 1859 } 1860 ios.width(25); 1861 internal(ios); 1862 { 1863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1864 std::string ex(str, iter.base()); 1865 assert(ex == "************************0"); 1866 assert(ios.width() == 0); 1867 } 1868 } 1869 ios.imbue(lg); 1870 { 1871 ios.width(0); 1872 { 1873 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1874 std::string ex(str, iter.base()); 1875 assert(ex == "0"); 1876 assert(ios.width() == 0); 1877 } 1878 ios.width(25); 1879 left(ios); 1880 { 1881 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1882 std::string ex(str, iter.base()); 1883 assert(ex == "0************************"); 1884 assert(ios.width() == 0); 1885 } 1886 ios.width(25); 1887 right(ios); 1888 { 1889 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1890 std::string ex(str, iter.base()); 1891 assert(ex == "************************0"); 1892 assert(ios.width() == 0); 1893 } 1894 ios.width(25); 1895 internal(ios); 1896 { 1897 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1898 std::string ex(str, iter.base()); 1899 assert(ex == "************************0"); 1900 assert(ios.width() == 0); 1901 } 1902 } 1903 } 1904 showpoint(ios); 1905 { 1906 ios.imbue(lc); 1907 { 1908 ios.width(0); 1909 { 1910 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1911 std::string ex(str, iter.base()); 1912 assert(ex == "0.000000000000000"); 1913 assert(ios.width() == 0); 1914 } 1915 ios.width(25); 1916 left(ios); 1917 { 1918 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1919 std::string ex(str, iter.base()); 1920 assert(ex == "0.000000000000000********"); 1921 assert(ios.width() == 0); 1922 } 1923 ios.width(25); 1924 right(ios); 1925 { 1926 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1927 std::string ex(str, iter.base()); 1928 assert(ex == "********0.000000000000000"); 1929 assert(ios.width() == 0); 1930 } 1931 ios.width(25); 1932 internal(ios); 1933 { 1934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1935 std::string ex(str, iter.base()); 1936 assert(ex == "********0.000000000000000"); 1937 assert(ios.width() == 0); 1938 } 1939 } 1940 ios.imbue(lg); 1941 { 1942 ios.width(0); 1943 { 1944 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1945 std::string ex(str, iter.base()); 1946 assert(ex == "0;000000000000000"); 1947 assert(ios.width() == 0); 1948 } 1949 ios.width(25); 1950 left(ios); 1951 { 1952 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1953 std::string ex(str, iter.base()); 1954 assert(ex == "0;000000000000000********"); 1955 assert(ios.width() == 0); 1956 } 1957 ios.width(25); 1958 right(ios); 1959 { 1960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1961 std::string ex(str, iter.base()); 1962 assert(ex == "********0;000000000000000"); 1963 assert(ios.width() == 0); 1964 } 1965 ios.width(25); 1966 internal(ios); 1967 { 1968 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1969 std::string ex(str, iter.base()); 1970 assert(ex == "********0;000000000000000"); 1971 assert(ios.width() == 0); 1972 } 1973 } 1974 } 1975 } 1976 showpos(ios); 1977 { 1978 noshowpoint(ios); 1979 { 1980 ios.imbue(lc); 1981 { 1982 ios.width(0); 1983 { 1984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1985 std::string ex(str, iter.base()); 1986 assert(ex == "+0"); 1987 assert(ios.width() == 0); 1988 } 1989 ios.width(25); 1990 left(ios); 1991 { 1992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 1993 std::string ex(str, iter.base()); 1994 assert(ex == "+0***********************"); 1995 assert(ios.width() == 0); 1996 } 1997 ios.width(25); 1998 right(ios); 1999 { 2000 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2001 std::string ex(str, iter.base()); 2002 assert(ex == "***********************+0"); 2003 assert(ios.width() == 0); 2004 } 2005 ios.width(25); 2006 internal(ios); 2007 { 2008 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2009 std::string ex(str, iter.base()); 2010 assert(ex == "+***********************0"); 2011 assert(ios.width() == 0); 2012 } 2013 } 2014 ios.imbue(lg); 2015 { 2016 ios.width(0); 2017 { 2018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2019 std::string ex(str, iter.base()); 2020 assert(ex == "+0"); 2021 assert(ios.width() == 0); 2022 } 2023 ios.width(25); 2024 left(ios); 2025 { 2026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2027 std::string ex(str, iter.base()); 2028 assert(ex == "+0***********************"); 2029 assert(ios.width() == 0); 2030 } 2031 ios.width(25); 2032 right(ios); 2033 { 2034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2035 std::string ex(str, iter.base()); 2036 assert(ex == "***********************+0"); 2037 assert(ios.width() == 0); 2038 } 2039 ios.width(25); 2040 internal(ios); 2041 { 2042 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2043 std::string ex(str, iter.base()); 2044 assert(ex == "+***********************0"); 2045 assert(ios.width() == 0); 2046 } 2047 } 2048 } 2049 showpoint(ios); 2050 { 2051 ios.imbue(lc); 2052 { 2053 ios.width(0); 2054 { 2055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2056 std::string ex(str, iter.base()); 2057 assert(ex == "+0.000000000000000"); 2058 assert(ios.width() == 0); 2059 } 2060 ios.width(25); 2061 left(ios); 2062 { 2063 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2064 std::string ex(str, iter.base()); 2065 assert(ex == "+0.000000000000000*******"); 2066 assert(ios.width() == 0); 2067 } 2068 ios.width(25); 2069 right(ios); 2070 { 2071 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2072 std::string ex(str, iter.base()); 2073 assert(ex == "*******+0.000000000000000"); 2074 assert(ios.width() == 0); 2075 } 2076 ios.width(25); 2077 internal(ios); 2078 { 2079 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2080 std::string ex(str, iter.base()); 2081 assert(ex == "+*******0.000000000000000"); 2082 assert(ios.width() == 0); 2083 } 2084 } 2085 ios.imbue(lg); 2086 { 2087 ios.width(0); 2088 { 2089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2090 std::string ex(str, iter.base()); 2091 assert(ex == "+0;000000000000000"); 2092 assert(ios.width() == 0); 2093 } 2094 ios.width(25); 2095 left(ios); 2096 { 2097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2098 std::string ex(str, iter.base()); 2099 assert(ex == "+0;000000000000000*******"); 2100 assert(ios.width() == 0); 2101 } 2102 ios.width(25); 2103 right(ios); 2104 { 2105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2106 std::string ex(str, iter.base()); 2107 assert(ex == "*******+0;000000000000000"); 2108 assert(ios.width() == 0); 2109 } 2110 ios.width(25); 2111 internal(ios); 2112 { 2113 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2114 std::string ex(str, iter.base()); 2115 assert(ex == "+*******0;000000000000000"); 2116 assert(ios.width() == 0); 2117 } 2118 } 2119 } 2120 } 2121 } 2122 uppercase(ios); 2123 { 2124 noshowpos(ios); 2125 { 2126 noshowpoint(ios); 2127 { 2128 ios.imbue(lc); 2129 { 2130 ios.width(0); 2131 { 2132 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2133 std::string ex(str, iter.base()); 2134 assert(ex == "0"); 2135 assert(ios.width() == 0); 2136 } 2137 ios.width(25); 2138 left(ios); 2139 { 2140 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2141 std::string ex(str, iter.base()); 2142 assert(ex == "0************************"); 2143 assert(ios.width() == 0); 2144 } 2145 ios.width(25); 2146 right(ios); 2147 { 2148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2149 std::string ex(str, iter.base()); 2150 assert(ex == "************************0"); 2151 assert(ios.width() == 0); 2152 } 2153 ios.width(25); 2154 internal(ios); 2155 { 2156 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2157 std::string ex(str, iter.base()); 2158 assert(ex == "************************0"); 2159 assert(ios.width() == 0); 2160 } 2161 } 2162 ios.imbue(lg); 2163 { 2164 ios.width(0); 2165 { 2166 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2167 std::string ex(str, iter.base()); 2168 assert(ex == "0"); 2169 assert(ios.width() == 0); 2170 } 2171 ios.width(25); 2172 left(ios); 2173 { 2174 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2175 std::string ex(str, iter.base()); 2176 assert(ex == "0************************"); 2177 assert(ios.width() == 0); 2178 } 2179 ios.width(25); 2180 right(ios); 2181 { 2182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2183 std::string ex(str, iter.base()); 2184 assert(ex == "************************0"); 2185 assert(ios.width() == 0); 2186 } 2187 ios.width(25); 2188 internal(ios); 2189 { 2190 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2191 std::string ex(str, iter.base()); 2192 assert(ex == "************************0"); 2193 assert(ios.width() == 0); 2194 } 2195 } 2196 } 2197 showpoint(ios); 2198 { 2199 ios.imbue(lc); 2200 { 2201 ios.width(0); 2202 { 2203 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2204 std::string ex(str, iter.base()); 2205 assert(ex == "0.000000000000000"); 2206 assert(ios.width() == 0); 2207 } 2208 ios.width(25); 2209 left(ios); 2210 { 2211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2212 std::string ex(str, iter.base()); 2213 assert(ex == "0.000000000000000********"); 2214 assert(ios.width() == 0); 2215 } 2216 ios.width(25); 2217 right(ios); 2218 { 2219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2220 std::string ex(str, iter.base()); 2221 assert(ex == "********0.000000000000000"); 2222 assert(ios.width() == 0); 2223 } 2224 ios.width(25); 2225 internal(ios); 2226 { 2227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2228 std::string ex(str, iter.base()); 2229 assert(ex == "********0.000000000000000"); 2230 assert(ios.width() == 0); 2231 } 2232 } 2233 ios.imbue(lg); 2234 { 2235 ios.width(0); 2236 { 2237 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2238 std::string ex(str, iter.base()); 2239 assert(ex == "0;000000000000000"); 2240 assert(ios.width() == 0); 2241 } 2242 ios.width(25); 2243 left(ios); 2244 { 2245 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2246 std::string ex(str, iter.base()); 2247 assert(ex == "0;000000000000000********"); 2248 assert(ios.width() == 0); 2249 } 2250 ios.width(25); 2251 right(ios); 2252 { 2253 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2254 std::string ex(str, iter.base()); 2255 assert(ex == "********0;000000000000000"); 2256 assert(ios.width() == 0); 2257 } 2258 ios.width(25); 2259 internal(ios); 2260 { 2261 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2262 std::string ex(str, iter.base()); 2263 assert(ex == "********0;000000000000000"); 2264 assert(ios.width() == 0); 2265 } 2266 } 2267 } 2268 } 2269 showpos(ios); 2270 { 2271 noshowpoint(ios); 2272 { 2273 ios.imbue(lc); 2274 { 2275 ios.width(0); 2276 { 2277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2278 std::string ex(str, iter.base()); 2279 assert(ex == "+0"); 2280 assert(ios.width() == 0); 2281 } 2282 ios.width(25); 2283 left(ios); 2284 { 2285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2286 std::string ex(str, iter.base()); 2287 assert(ex == "+0***********************"); 2288 assert(ios.width() == 0); 2289 } 2290 ios.width(25); 2291 right(ios); 2292 { 2293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2294 std::string ex(str, iter.base()); 2295 assert(ex == "***********************+0"); 2296 assert(ios.width() == 0); 2297 } 2298 ios.width(25); 2299 internal(ios); 2300 { 2301 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2302 std::string ex(str, iter.base()); 2303 assert(ex == "+***********************0"); 2304 assert(ios.width() == 0); 2305 } 2306 } 2307 ios.imbue(lg); 2308 { 2309 ios.width(0); 2310 { 2311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2312 std::string ex(str, iter.base()); 2313 assert(ex == "+0"); 2314 assert(ios.width() == 0); 2315 } 2316 ios.width(25); 2317 left(ios); 2318 { 2319 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2320 std::string ex(str, iter.base()); 2321 assert(ex == "+0***********************"); 2322 assert(ios.width() == 0); 2323 } 2324 ios.width(25); 2325 right(ios); 2326 { 2327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2328 std::string ex(str, iter.base()); 2329 assert(ex == "***********************+0"); 2330 assert(ios.width() == 0); 2331 } 2332 ios.width(25); 2333 internal(ios); 2334 { 2335 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2336 std::string ex(str, iter.base()); 2337 assert(ex == "+***********************0"); 2338 assert(ios.width() == 0); 2339 } 2340 } 2341 } 2342 showpoint(ios); 2343 { 2344 ios.imbue(lc); 2345 { 2346 ios.width(0); 2347 { 2348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2349 std::string ex(str, iter.base()); 2350 assert(ex == "+0.000000000000000"); 2351 assert(ios.width() == 0); 2352 } 2353 ios.width(25); 2354 left(ios); 2355 { 2356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2357 std::string ex(str, iter.base()); 2358 assert(ex == "+0.000000000000000*******"); 2359 assert(ios.width() == 0); 2360 } 2361 ios.width(25); 2362 right(ios); 2363 { 2364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2365 std::string ex(str, iter.base()); 2366 assert(ex == "*******+0.000000000000000"); 2367 assert(ios.width() == 0); 2368 } 2369 ios.width(25); 2370 internal(ios); 2371 { 2372 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2373 std::string ex(str, iter.base()); 2374 assert(ex == "+*******0.000000000000000"); 2375 assert(ios.width() == 0); 2376 } 2377 } 2378 ios.imbue(lg); 2379 { 2380 ios.width(0); 2381 { 2382 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2383 std::string ex(str, iter.base()); 2384 assert(ex == "+0;000000000000000"); 2385 assert(ios.width() == 0); 2386 } 2387 ios.width(25); 2388 left(ios); 2389 { 2390 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2391 std::string ex(str, iter.base()); 2392 assert(ex == "+0;000000000000000*******"); 2393 assert(ios.width() == 0); 2394 } 2395 ios.width(25); 2396 right(ios); 2397 { 2398 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2399 std::string ex(str, iter.base()); 2400 assert(ex == "*******+0;000000000000000"); 2401 assert(ios.width() == 0); 2402 } 2403 ios.width(25); 2404 internal(ios); 2405 { 2406 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2407 std::string ex(str, iter.base()); 2408 assert(ex == "+*******0;000000000000000"); 2409 assert(ios.width() == 0); 2410 } 2411 } 2412 } 2413 } 2414 } 2415 } 2416 ios.precision(60); 2417 { 2418 nouppercase(ios); 2419 { 2420 noshowpos(ios); 2421 { 2422 noshowpoint(ios); 2423 { 2424 ios.imbue(lc); 2425 { 2426 ios.width(0); 2427 { 2428 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2429 std::string ex(str, iter.base()); 2430 assert(ex == "0"); 2431 assert(ios.width() == 0); 2432 } 2433 ios.width(25); 2434 left(ios); 2435 { 2436 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2437 std::string ex(str, iter.base()); 2438 assert(ex == "0************************"); 2439 assert(ios.width() == 0); 2440 } 2441 ios.width(25); 2442 right(ios); 2443 { 2444 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2445 std::string ex(str, iter.base()); 2446 assert(ex == "************************0"); 2447 assert(ios.width() == 0); 2448 } 2449 ios.width(25); 2450 internal(ios); 2451 { 2452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2453 std::string ex(str, iter.base()); 2454 assert(ex == "************************0"); 2455 assert(ios.width() == 0); 2456 } 2457 } 2458 ios.imbue(lg); 2459 { 2460 ios.width(0); 2461 { 2462 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2463 std::string ex(str, iter.base()); 2464 assert(ex == "0"); 2465 assert(ios.width() == 0); 2466 } 2467 ios.width(25); 2468 left(ios); 2469 { 2470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2471 std::string ex(str, iter.base()); 2472 assert(ex == "0************************"); 2473 assert(ios.width() == 0); 2474 } 2475 ios.width(25); 2476 right(ios); 2477 { 2478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2479 std::string ex(str, iter.base()); 2480 assert(ex == "************************0"); 2481 assert(ios.width() == 0); 2482 } 2483 ios.width(25); 2484 internal(ios); 2485 { 2486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2487 std::string ex(str, iter.base()); 2488 assert(ex == "************************0"); 2489 assert(ios.width() == 0); 2490 } 2491 } 2492 } 2493 showpoint(ios); 2494 { 2495 ios.imbue(lc); 2496 { 2497 ios.width(0); 2498 { 2499 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2500 std::string ex(str, iter.base()); 2501 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2502 assert(ios.width() == 0); 2503 } 2504 ios.width(25); 2505 left(ios); 2506 { 2507 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2508 std::string ex(str, iter.base()); 2509 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2510 assert(ios.width() == 0); 2511 } 2512 ios.width(25); 2513 right(ios); 2514 { 2515 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2516 std::string ex(str, iter.base()); 2517 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2518 assert(ios.width() == 0); 2519 } 2520 ios.width(25); 2521 internal(ios); 2522 { 2523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2524 std::string ex(str, iter.base()); 2525 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2526 assert(ios.width() == 0); 2527 } 2528 } 2529 ios.imbue(lg); 2530 { 2531 ios.width(0); 2532 { 2533 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2534 std::string ex(str, iter.base()); 2535 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2536 assert(ios.width() == 0); 2537 } 2538 ios.width(25); 2539 left(ios); 2540 { 2541 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2542 std::string ex(str, iter.base()); 2543 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2544 assert(ios.width() == 0); 2545 } 2546 ios.width(25); 2547 right(ios); 2548 { 2549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2550 std::string ex(str, iter.base()); 2551 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2552 assert(ios.width() == 0); 2553 } 2554 ios.width(25); 2555 internal(ios); 2556 { 2557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2558 std::string ex(str, iter.base()); 2559 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2560 assert(ios.width() == 0); 2561 } 2562 } 2563 } 2564 } 2565 showpos(ios); 2566 { 2567 noshowpoint(ios); 2568 { 2569 ios.imbue(lc); 2570 { 2571 ios.width(0); 2572 { 2573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2574 std::string ex(str, iter.base()); 2575 assert(ex == "+0"); 2576 assert(ios.width() == 0); 2577 } 2578 ios.width(25); 2579 left(ios); 2580 { 2581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2582 std::string ex(str, iter.base()); 2583 assert(ex == "+0***********************"); 2584 assert(ios.width() == 0); 2585 } 2586 ios.width(25); 2587 right(ios); 2588 { 2589 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2590 std::string ex(str, iter.base()); 2591 assert(ex == "***********************+0"); 2592 assert(ios.width() == 0); 2593 } 2594 ios.width(25); 2595 internal(ios); 2596 { 2597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2598 std::string ex(str, iter.base()); 2599 assert(ex == "+***********************0"); 2600 assert(ios.width() == 0); 2601 } 2602 } 2603 ios.imbue(lg); 2604 { 2605 ios.width(0); 2606 { 2607 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2608 std::string ex(str, iter.base()); 2609 assert(ex == "+0"); 2610 assert(ios.width() == 0); 2611 } 2612 ios.width(25); 2613 left(ios); 2614 { 2615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2616 std::string ex(str, iter.base()); 2617 assert(ex == "+0***********************"); 2618 assert(ios.width() == 0); 2619 } 2620 ios.width(25); 2621 right(ios); 2622 { 2623 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2624 std::string ex(str, iter.base()); 2625 assert(ex == "***********************+0"); 2626 assert(ios.width() == 0); 2627 } 2628 ios.width(25); 2629 internal(ios); 2630 { 2631 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2632 std::string ex(str, iter.base()); 2633 assert(ex == "+***********************0"); 2634 assert(ios.width() == 0); 2635 } 2636 } 2637 } 2638 showpoint(ios); 2639 { 2640 ios.imbue(lc); 2641 { 2642 ios.width(0); 2643 { 2644 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2645 std::string ex(str, iter.base()); 2646 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2647 assert(ios.width() == 0); 2648 } 2649 ios.width(25); 2650 left(ios); 2651 { 2652 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2653 std::string ex(str, iter.base()); 2654 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2655 assert(ios.width() == 0); 2656 } 2657 ios.width(25); 2658 right(ios); 2659 { 2660 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2661 std::string ex(str, iter.base()); 2662 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2663 assert(ios.width() == 0); 2664 } 2665 ios.width(25); 2666 internal(ios); 2667 { 2668 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2669 std::string ex(str, iter.base()); 2670 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2671 assert(ios.width() == 0); 2672 } 2673 } 2674 ios.imbue(lg); 2675 { 2676 ios.width(0); 2677 { 2678 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2679 std::string ex(str, iter.base()); 2680 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2681 assert(ios.width() == 0); 2682 } 2683 ios.width(25); 2684 left(ios); 2685 { 2686 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2687 std::string ex(str, iter.base()); 2688 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2689 assert(ios.width() == 0); 2690 } 2691 ios.width(25); 2692 right(ios); 2693 { 2694 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2695 std::string ex(str, iter.base()); 2696 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2697 assert(ios.width() == 0); 2698 } 2699 ios.width(25); 2700 internal(ios); 2701 { 2702 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2703 std::string ex(str, iter.base()); 2704 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2705 assert(ios.width() == 0); 2706 } 2707 } 2708 } 2709 } 2710 } 2711 uppercase(ios); 2712 { 2713 noshowpos(ios); 2714 { 2715 noshowpoint(ios); 2716 { 2717 ios.imbue(lc); 2718 { 2719 ios.width(0); 2720 { 2721 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2722 std::string ex(str, iter.base()); 2723 assert(ex == "0"); 2724 assert(ios.width() == 0); 2725 } 2726 ios.width(25); 2727 left(ios); 2728 { 2729 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2730 std::string ex(str, iter.base()); 2731 assert(ex == "0************************"); 2732 assert(ios.width() == 0); 2733 } 2734 ios.width(25); 2735 right(ios); 2736 { 2737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2738 std::string ex(str, iter.base()); 2739 assert(ex == "************************0"); 2740 assert(ios.width() == 0); 2741 } 2742 ios.width(25); 2743 internal(ios); 2744 { 2745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2746 std::string ex(str, iter.base()); 2747 assert(ex == "************************0"); 2748 assert(ios.width() == 0); 2749 } 2750 } 2751 ios.imbue(lg); 2752 { 2753 ios.width(0); 2754 { 2755 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2756 std::string ex(str, iter.base()); 2757 assert(ex == "0"); 2758 assert(ios.width() == 0); 2759 } 2760 ios.width(25); 2761 left(ios); 2762 { 2763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2764 std::string ex(str, iter.base()); 2765 assert(ex == "0************************"); 2766 assert(ios.width() == 0); 2767 } 2768 ios.width(25); 2769 right(ios); 2770 { 2771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2772 std::string ex(str, iter.base()); 2773 assert(ex == "************************0"); 2774 assert(ios.width() == 0); 2775 } 2776 ios.width(25); 2777 internal(ios); 2778 { 2779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2780 std::string ex(str, iter.base()); 2781 assert(ex == "************************0"); 2782 assert(ios.width() == 0); 2783 } 2784 } 2785 } 2786 showpoint(ios); 2787 { 2788 ios.imbue(lc); 2789 { 2790 ios.width(0); 2791 { 2792 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2793 std::string ex(str, iter.base()); 2794 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2795 assert(ios.width() == 0); 2796 } 2797 ios.width(25); 2798 left(ios); 2799 { 2800 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2801 std::string ex(str, iter.base()); 2802 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2803 assert(ios.width() == 0); 2804 } 2805 ios.width(25); 2806 right(ios); 2807 { 2808 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2809 std::string ex(str, iter.base()); 2810 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2811 assert(ios.width() == 0); 2812 } 2813 ios.width(25); 2814 internal(ios); 2815 { 2816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2817 std::string ex(str, iter.base()); 2818 assert(ex == "0.00000000000000000000000000000000000000000000000000000000000"); 2819 assert(ios.width() == 0); 2820 } 2821 } 2822 ios.imbue(lg); 2823 { 2824 ios.width(0); 2825 { 2826 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2827 std::string ex(str, iter.base()); 2828 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2829 assert(ios.width() == 0); 2830 } 2831 ios.width(25); 2832 left(ios); 2833 { 2834 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2835 std::string ex(str, iter.base()); 2836 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2837 assert(ios.width() == 0); 2838 } 2839 ios.width(25); 2840 right(ios); 2841 { 2842 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2843 std::string ex(str, iter.base()); 2844 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2845 assert(ios.width() == 0); 2846 } 2847 ios.width(25); 2848 internal(ios); 2849 { 2850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2851 std::string ex(str, iter.base()); 2852 assert(ex == "0;00000000000000000000000000000000000000000000000000000000000"); 2853 assert(ios.width() == 0); 2854 } 2855 } 2856 } 2857 } 2858 showpos(ios); 2859 { 2860 noshowpoint(ios); 2861 { 2862 ios.imbue(lc); 2863 { 2864 ios.width(0); 2865 { 2866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2867 std::string ex(str, iter.base()); 2868 assert(ex == "+0"); 2869 assert(ios.width() == 0); 2870 } 2871 ios.width(25); 2872 left(ios); 2873 { 2874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2875 std::string ex(str, iter.base()); 2876 assert(ex == "+0***********************"); 2877 assert(ios.width() == 0); 2878 } 2879 ios.width(25); 2880 right(ios); 2881 { 2882 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2883 std::string ex(str, iter.base()); 2884 assert(ex == "***********************+0"); 2885 assert(ios.width() == 0); 2886 } 2887 ios.width(25); 2888 internal(ios); 2889 { 2890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2891 std::string ex(str, iter.base()); 2892 assert(ex == "+***********************0"); 2893 assert(ios.width() == 0); 2894 } 2895 } 2896 ios.imbue(lg); 2897 { 2898 ios.width(0); 2899 { 2900 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2901 std::string ex(str, iter.base()); 2902 assert(ex == "+0"); 2903 assert(ios.width() == 0); 2904 } 2905 ios.width(25); 2906 left(ios); 2907 { 2908 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2909 std::string ex(str, iter.base()); 2910 assert(ex == "+0***********************"); 2911 assert(ios.width() == 0); 2912 } 2913 ios.width(25); 2914 right(ios); 2915 { 2916 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2917 std::string ex(str, iter.base()); 2918 assert(ex == "***********************+0"); 2919 assert(ios.width() == 0); 2920 } 2921 ios.width(25); 2922 internal(ios); 2923 { 2924 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2925 std::string ex(str, iter.base()); 2926 assert(ex == "+***********************0"); 2927 assert(ios.width() == 0); 2928 } 2929 } 2930 } 2931 showpoint(ios); 2932 { 2933 ios.imbue(lc); 2934 { 2935 ios.width(0); 2936 { 2937 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2938 std::string ex(str, iter.base()); 2939 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2940 assert(ios.width() == 0); 2941 } 2942 ios.width(25); 2943 left(ios); 2944 { 2945 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2946 std::string ex(str, iter.base()); 2947 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2948 assert(ios.width() == 0); 2949 } 2950 ios.width(25); 2951 right(ios); 2952 { 2953 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2954 std::string ex(str, iter.base()); 2955 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2956 assert(ios.width() == 0); 2957 } 2958 ios.width(25); 2959 internal(ios); 2960 { 2961 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2962 std::string ex(str, iter.base()); 2963 assert(ex == "+0.00000000000000000000000000000000000000000000000000000000000"); 2964 assert(ios.width() == 0); 2965 } 2966 } 2967 ios.imbue(lg); 2968 { 2969 ios.width(0); 2970 { 2971 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2972 std::string ex(str, iter.base()); 2973 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2974 assert(ios.width() == 0); 2975 } 2976 ios.width(25); 2977 left(ios); 2978 { 2979 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2980 std::string ex(str, iter.base()); 2981 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2982 assert(ios.width() == 0); 2983 } 2984 ios.width(25); 2985 right(ios); 2986 { 2987 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2988 std::string ex(str, iter.base()); 2989 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2990 assert(ios.width() == 0); 2991 } 2992 ios.width(25); 2993 internal(ios); 2994 { 2995 iter = f.put(output_iterator<char*>(str), ios, '*', v); 2996 std::string ex(str, iter.base()); 2997 assert(ex == "+0;00000000000000000000000000000000000000000000000000000000000"); 2998 assert(ios.width() == 0); 2999 } 3000 } 3001 } 3002 } 3003 } 3004 } 3005 } 3006 } 3007 } 3008 3009 void test2() 3010 { 3011 char str[200]; 3012 output_iterator<char*> iter; 3013 std::locale lc = std::locale::classic(); 3014 std::locale lg(lc, new my_numpunct); 3015 const my_facet f(1); 3016 { 3017 double v = 1234567890.125; 3018 std::ios ios(0); 3019 // %g 3020 { 3021 ios.precision(0); 3022 { 3023 nouppercase(ios); 3024 { 3025 noshowpos(ios); 3026 { 3027 noshowpoint(ios); 3028 { 3029 ios.imbue(lc); 3030 { 3031 ios.width(0); 3032 { 3033 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3034 std::string ex(str, iter.base()); 3035 assert(ex == "1e+09"); 3036 assert(ios.width() == 0); 3037 } 3038 ios.width(25); 3039 left(ios); 3040 { 3041 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3042 std::string ex(str, iter.base()); 3043 assert(ex == "1e+09********************"); 3044 assert(ios.width() == 0); 3045 } 3046 ios.width(25); 3047 right(ios); 3048 { 3049 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3050 std::string ex(str, iter.base()); 3051 assert(ex == "********************1e+09"); 3052 assert(ios.width() == 0); 3053 } 3054 ios.width(25); 3055 internal(ios); 3056 { 3057 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3058 std::string ex(str, iter.base()); 3059 assert(ex == "********************1e+09"); 3060 assert(ios.width() == 0); 3061 } 3062 } 3063 ios.imbue(lg); 3064 { 3065 ios.width(0); 3066 { 3067 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3068 std::string ex(str, iter.base()); 3069 assert(ex == "1e+09"); 3070 assert(ios.width() == 0); 3071 } 3072 ios.width(25); 3073 left(ios); 3074 { 3075 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3076 std::string ex(str, iter.base()); 3077 assert(ex == "1e+09********************"); 3078 assert(ios.width() == 0); 3079 } 3080 ios.width(25); 3081 right(ios); 3082 { 3083 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3084 std::string ex(str, iter.base()); 3085 assert(ex == "********************1e+09"); 3086 assert(ios.width() == 0); 3087 } 3088 ios.width(25); 3089 internal(ios); 3090 { 3091 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3092 std::string ex(str, iter.base()); 3093 assert(ex == "********************1e+09"); 3094 assert(ios.width() == 0); 3095 } 3096 } 3097 } 3098 showpoint(ios); 3099 { 3100 ios.imbue(lc); 3101 { 3102 ios.width(0); 3103 { 3104 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3105 std::string ex(str, iter.base()); 3106 assert(ex == "1.e+09"); 3107 assert(ios.width() == 0); 3108 } 3109 ios.width(25); 3110 left(ios); 3111 { 3112 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3113 std::string ex(str, iter.base()); 3114 assert(ex == "1.e+09*******************"); 3115 assert(ios.width() == 0); 3116 } 3117 ios.width(25); 3118 right(ios); 3119 { 3120 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3121 std::string ex(str, iter.base()); 3122 assert(ex == "*******************1.e+09"); 3123 assert(ios.width() == 0); 3124 } 3125 ios.width(25); 3126 internal(ios); 3127 { 3128 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3129 std::string ex(str, iter.base()); 3130 assert(ex == "*******************1.e+09"); 3131 assert(ios.width() == 0); 3132 } 3133 } 3134 ios.imbue(lg); 3135 { 3136 ios.width(0); 3137 { 3138 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3139 std::string ex(str, iter.base()); 3140 assert(ex == "1;e+09"); 3141 assert(ios.width() == 0); 3142 } 3143 ios.width(25); 3144 left(ios); 3145 { 3146 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3147 std::string ex(str, iter.base()); 3148 assert(ex == "1;e+09*******************"); 3149 assert(ios.width() == 0); 3150 } 3151 ios.width(25); 3152 right(ios); 3153 { 3154 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3155 std::string ex(str, iter.base()); 3156 assert(ex == "*******************1;e+09"); 3157 assert(ios.width() == 0); 3158 } 3159 ios.width(25); 3160 internal(ios); 3161 { 3162 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3163 std::string ex(str, iter.base()); 3164 assert(ex == "*******************1;e+09"); 3165 assert(ios.width() == 0); 3166 } 3167 } 3168 } 3169 } 3170 showpos(ios); 3171 { 3172 noshowpoint(ios); 3173 { 3174 ios.imbue(lc); 3175 { 3176 ios.width(0); 3177 { 3178 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3179 std::string ex(str, iter.base()); 3180 assert(ex == "+1e+09"); 3181 assert(ios.width() == 0); 3182 } 3183 ios.width(25); 3184 left(ios); 3185 { 3186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3187 std::string ex(str, iter.base()); 3188 assert(ex == "+1e+09*******************"); 3189 assert(ios.width() == 0); 3190 } 3191 ios.width(25); 3192 right(ios); 3193 { 3194 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3195 std::string ex(str, iter.base()); 3196 assert(ex == "*******************+1e+09"); 3197 assert(ios.width() == 0); 3198 } 3199 ios.width(25); 3200 internal(ios); 3201 { 3202 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3203 std::string ex(str, iter.base()); 3204 assert(ex == "+*******************1e+09"); 3205 assert(ios.width() == 0); 3206 } 3207 } 3208 ios.imbue(lg); 3209 { 3210 ios.width(0); 3211 { 3212 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3213 std::string ex(str, iter.base()); 3214 assert(ex == "+1e+09"); 3215 assert(ios.width() == 0); 3216 } 3217 ios.width(25); 3218 left(ios); 3219 { 3220 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3221 std::string ex(str, iter.base()); 3222 assert(ex == "+1e+09*******************"); 3223 assert(ios.width() == 0); 3224 } 3225 ios.width(25); 3226 right(ios); 3227 { 3228 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3229 std::string ex(str, iter.base()); 3230 assert(ex == "*******************+1e+09"); 3231 assert(ios.width() == 0); 3232 } 3233 ios.width(25); 3234 internal(ios); 3235 { 3236 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3237 std::string ex(str, iter.base()); 3238 assert(ex == "+*******************1e+09"); 3239 assert(ios.width() == 0); 3240 } 3241 } 3242 } 3243 showpoint(ios); 3244 { 3245 ios.imbue(lc); 3246 { 3247 ios.width(0); 3248 { 3249 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3250 std::string ex(str, iter.base()); 3251 assert(ex == "+1.e+09"); 3252 assert(ios.width() == 0); 3253 } 3254 ios.width(25); 3255 left(ios); 3256 { 3257 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3258 std::string ex(str, iter.base()); 3259 assert(ex == "+1.e+09******************"); 3260 assert(ios.width() == 0); 3261 } 3262 ios.width(25); 3263 right(ios); 3264 { 3265 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3266 std::string ex(str, iter.base()); 3267 assert(ex == "******************+1.e+09"); 3268 assert(ios.width() == 0); 3269 } 3270 ios.width(25); 3271 internal(ios); 3272 { 3273 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3274 std::string ex(str, iter.base()); 3275 assert(ex == "+******************1.e+09"); 3276 assert(ios.width() == 0); 3277 } 3278 } 3279 ios.imbue(lg); 3280 { 3281 ios.width(0); 3282 { 3283 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3284 std::string ex(str, iter.base()); 3285 assert(ex == "+1;e+09"); 3286 assert(ios.width() == 0); 3287 } 3288 ios.width(25); 3289 left(ios); 3290 { 3291 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3292 std::string ex(str, iter.base()); 3293 assert(ex == "+1;e+09******************"); 3294 assert(ios.width() == 0); 3295 } 3296 ios.width(25); 3297 right(ios); 3298 { 3299 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3300 std::string ex(str, iter.base()); 3301 assert(ex == "******************+1;e+09"); 3302 assert(ios.width() == 0); 3303 } 3304 ios.width(25); 3305 internal(ios); 3306 { 3307 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3308 std::string ex(str, iter.base()); 3309 assert(ex == "+******************1;e+09"); 3310 assert(ios.width() == 0); 3311 } 3312 } 3313 } 3314 } 3315 } 3316 uppercase(ios); 3317 { 3318 noshowpos(ios); 3319 { 3320 noshowpoint(ios); 3321 { 3322 ios.imbue(lc); 3323 { 3324 ios.width(0); 3325 { 3326 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3327 std::string ex(str, iter.base()); 3328 assert(ex == "1E+09"); 3329 assert(ios.width() == 0); 3330 } 3331 ios.width(25); 3332 left(ios); 3333 { 3334 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3335 std::string ex(str, iter.base()); 3336 assert(ex == "1E+09********************"); 3337 assert(ios.width() == 0); 3338 } 3339 ios.width(25); 3340 right(ios); 3341 { 3342 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3343 std::string ex(str, iter.base()); 3344 assert(ex == "********************1E+09"); 3345 assert(ios.width() == 0); 3346 } 3347 ios.width(25); 3348 internal(ios); 3349 { 3350 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3351 std::string ex(str, iter.base()); 3352 assert(ex == "********************1E+09"); 3353 assert(ios.width() == 0); 3354 } 3355 } 3356 ios.imbue(lg); 3357 { 3358 ios.width(0); 3359 { 3360 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3361 std::string ex(str, iter.base()); 3362 assert(ex == "1E+09"); 3363 assert(ios.width() == 0); 3364 } 3365 ios.width(25); 3366 left(ios); 3367 { 3368 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3369 std::string ex(str, iter.base()); 3370 assert(ex == "1E+09********************"); 3371 assert(ios.width() == 0); 3372 } 3373 ios.width(25); 3374 right(ios); 3375 { 3376 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3377 std::string ex(str, iter.base()); 3378 assert(ex == "********************1E+09"); 3379 assert(ios.width() == 0); 3380 } 3381 ios.width(25); 3382 internal(ios); 3383 { 3384 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3385 std::string ex(str, iter.base()); 3386 assert(ex == "********************1E+09"); 3387 assert(ios.width() == 0); 3388 } 3389 } 3390 } 3391 showpoint(ios); 3392 { 3393 ios.imbue(lc); 3394 { 3395 ios.width(0); 3396 { 3397 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3398 std::string ex(str, iter.base()); 3399 assert(ex == "1.E+09"); 3400 assert(ios.width() == 0); 3401 } 3402 ios.width(25); 3403 left(ios); 3404 { 3405 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3406 std::string ex(str, iter.base()); 3407 assert(ex == "1.E+09*******************"); 3408 assert(ios.width() == 0); 3409 } 3410 ios.width(25); 3411 right(ios); 3412 { 3413 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3414 std::string ex(str, iter.base()); 3415 assert(ex == "*******************1.E+09"); 3416 assert(ios.width() == 0); 3417 } 3418 ios.width(25); 3419 internal(ios); 3420 { 3421 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3422 std::string ex(str, iter.base()); 3423 assert(ex == "*******************1.E+09"); 3424 assert(ios.width() == 0); 3425 } 3426 } 3427 ios.imbue(lg); 3428 { 3429 ios.width(0); 3430 { 3431 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3432 std::string ex(str, iter.base()); 3433 assert(ex == "1;E+09"); 3434 assert(ios.width() == 0); 3435 } 3436 ios.width(25); 3437 left(ios); 3438 { 3439 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3440 std::string ex(str, iter.base()); 3441 assert(ex == "1;E+09*******************"); 3442 assert(ios.width() == 0); 3443 } 3444 ios.width(25); 3445 right(ios); 3446 { 3447 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3448 std::string ex(str, iter.base()); 3449 assert(ex == "*******************1;E+09"); 3450 assert(ios.width() == 0); 3451 } 3452 ios.width(25); 3453 internal(ios); 3454 { 3455 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3456 std::string ex(str, iter.base()); 3457 assert(ex == "*******************1;E+09"); 3458 assert(ios.width() == 0); 3459 } 3460 } 3461 } 3462 } 3463 showpos(ios); 3464 { 3465 noshowpoint(ios); 3466 { 3467 ios.imbue(lc); 3468 { 3469 ios.width(0); 3470 { 3471 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3472 std::string ex(str, iter.base()); 3473 assert(ex == "+1E+09"); 3474 assert(ios.width() == 0); 3475 } 3476 ios.width(25); 3477 left(ios); 3478 { 3479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3480 std::string ex(str, iter.base()); 3481 assert(ex == "+1E+09*******************"); 3482 assert(ios.width() == 0); 3483 } 3484 ios.width(25); 3485 right(ios); 3486 { 3487 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3488 std::string ex(str, iter.base()); 3489 assert(ex == "*******************+1E+09"); 3490 assert(ios.width() == 0); 3491 } 3492 ios.width(25); 3493 internal(ios); 3494 { 3495 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3496 std::string ex(str, iter.base()); 3497 assert(ex == "+*******************1E+09"); 3498 assert(ios.width() == 0); 3499 } 3500 } 3501 ios.imbue(lg); 3502 { 3503 ios.width(0); 3504 { 3505 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3506 std::string ex(str, iter.base()); 3507 assert(ex == "+1E+09"); 3508 assert(ios.width() == 0); 3509 } 3510 ios.width(25); 3511 left(ios); 3512 { 3513 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3514 std::string ex(str, iter.base()); 3515 assert(ex == "+1E+09*******************"); 3516 assert(ios.width() == 0); 3517 } 3518 ios.width(25); 3519 right(ios); 3520 { 3521 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3522 std::string ex(str, iter.base()); 3523 assert(ex == "*******************+1E+09"); 3524 assert(ios.width() == 0); 3525 } 3526 ios.width(25); 3527 internal(ios); 3528 { 3529 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3530 std::string ex(str, iter.base()); 3531 assert(ex == "+*******************1E+09"); 3532 assert(ios.width() == 0); 3533 } 3534 } 3535 } 3536 showpoint(ios); 3537 { 3538 ios.imbue(lc); 3539 { 3540 ios.width(0); 3541 { 3542 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3543 std::string ex(str, iter.base()); 3544 assert(ex == "+1.E+09"); 3545 assert(ios.width() == 0); 3546 } 3547 ios.width(25); 3548 left(ios); 3549 { 3550 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3551 std::string ex(str, iter.base()); 3552 assert(ex == "+1.E+09******************"); 3553 assert(ios.width() == 0); 3554 } 3555 ios.width(25); 3556 right(ios); 3557 { 3558 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3559 std::string ex(str, iter.base()); 3560 assert(ex == "******************+1.E+09"); 3561 assert(ios.width() == 0); 3562 } 3563 ios.width(25); 3564 internal(ios); 3565 { 3566 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3567 std::string ex(str, iter.base()); 3568 assert(ex == "+******************1.E+09"); 3569 assert(ios.width() == 0); 3570 } 3571 } 3572 ios.imbue(lg); 3573 { 3574 ios.width(0); 3575 { 3576 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3577 std::string ex(str, iter.base()); 3578 assert(ex == "+1;E+09"); 3579 assert(ios.width() == 0); 3580 } 3581 ios.width(25); 3582 left(ios); 3583 { 3584 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3585 std::string ex(str, iter.base()); 3586 assert(ex == "+1;E+09******************"); 3587 assert(ios.width() == 0); 3588 } 3589 ios.width(25); 3590 right(ios); 3591 { 3592 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3593 std::string ex(str, iter.base()); 3594 assert(ex == "******************+1;E+09"); 3595 assert(ios.width() == 0); 3596 } 3597 ios.width(25); 3598 internal(ios); 3599 { 3600 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3601 std::string ex(str, iter.base()); 3602 assert(ex == "+******************1;E+09"); 3603 assert(ios.width() == 0); 3604 } 3605 } 3606 } 3607 } 3608 } 3609 } 3610 ios.precision(1); 3611 { 3612 nouppercase(ios); 3613 { 3614 noshowpos(ios); 3615 { 3616 noshowpoint(ios); 3617 { 3618 ios.imbue(lc); 3619 { 3620 ios.width(0); 3621 { 3622 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3623 std::string ex(str, iter.base()); 3624 assert(ex == "1e+09"); 3625 assert(ios.width() == 0); 3626 } 3627 ios.width(25); 3628 left(ios); 3629 { 3630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3631 std::string ex(str, iter.base()); 3632 assert(ex == "1e+09********************"); 3633 assert(ios.width() == 0); 3634 } 3635 ios.width(25); 3636 right(ios); 3637 { 3638 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3639 std::string ex(str, iter.base()); 3640 assert(ex == "********************1e+09"); 3641 assert(ios.width() == 0); 3642 } 3643 ios.width(25); 3644 internal(ios); 3645 { 3646 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3647 std::string ex(str, iter.base()); 3648 assert(ex == "********************1e+09"); 3649 assert(ios.width() == 0); 3650 } 3651 } 3652 ios.imbue(lg); 3653 { 3654 ios.width(0); 3655 { 3656 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3657 std::string ex(str, iter.base()); 3658 assert(ex == "1e+09"); 3659 assert(ios.width() == 0); 3660 } 3661 ios.width(25); 3662 left(ios); 3663 { 3664 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3665 std::string ex(str, iter.base()); 3666 assert(ex == "1e+09********************"); 3667 assert(ios.width() == 0); 3668 } 3669 ios.width(25); 3670 right(ios); 3671 { 3672 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3673 std::string ex(str, iter.base()); 3674 assert(ex == "********************1e+09"); 3675 assert(ios.width() == 0); 3676 } 3677 ios.width(25); 3678 internal(ios); 3679 { 3680 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3681 std::string ex(str, iter.base()); 3682 assert(ex == "********************1e+09"); 3683 assert(ios.width() == 0); 3684 } 3685 } 3686 } 3687 showpoint(ios); 3688 { 3689 ios.imbue(lc); 3690 { 3691 ios.width(0); 3692 { 3693 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3694 std::string ex(str, iter.base()); 3695 assert(ex == "1.e+09"); 3696 assert(ios.width() == 0); 3697 } 3698 ios.width(25); 3699 left(ios); 3700 { 3701 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3702 std::string ex(str, iter.base()); 3703 assert(ex == "1.e+09*******************"); 3704 assert(ios.width() == 0); 3705 } 3706 ios.width(25); 3707 right(ios); 3708 { 3709 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3710 std::string ex(str, iter.base()); 3711 assert(ex == "*******************1.e+09"); 3712 assert(ios.width() == 0); 3713 } 3714 ios.width(25); 3715 internal(ios); 3716 { 3717 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3718 std::string ex(str, iter.base()); 3719 assert(ex == "*******************1.e+09"); 3720 assert(ios.width() == 0); 3721 } 3722 } 3723 ios.imbue(lg); 3724 { 3725 ios.width(0); 3726 { 3727 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3728 std::string ex(str, iter.base()); 3729 assert(ex == "1;e+09"); 3730 assert(ios.width() == 0); 3731 } 3732 ios.width(25); 3733 left(ios); 3734 { 3735 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3736 std::string ex(str, iter.base()); 3737 assert(ex == "1;e+09*******************"); 3738 assert(ios.width() == 0); 3739 } 3740 ios.width(25); 3741 right(ios); 3742 { 3743 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3744 std::string ex(str, iter.base()); 3745 assert(ex == "*******************1;e+09"); 3746 assert(ios.width() == 0); 3747 } 3748 ios.width(25); 3749 internal(ios); 3750 { 3751 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3752 std::string ex(str, iter.base()); 3753 assert(ex == "*******************1;e+09"); 3754 assert(ios.width() == 0); 3755 } 3756 } 3757 } 3758 } 3759 showpos(ios); 3760 { 3761 noshowpoint(ios); 3762 { 3763 ios.imbue(lc); 3764 { 3765 ios.width(0); 3766 { 3767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3768 std::string ex(str, iter.base()); 3769 assert(ex == "+1e+09"); 3770 assert(ios.width() == 0); 3771 } 3772 ios.width(25); 3773 left(ios); 3774 { 3775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3776 std::string ex(str, iter.base()); 3777 assert(ex == "+1e+09*******************"); 3778 assert(ios.width() == 0); 3779 } 3780 ios.width(25); 3781 right(ios); 3782 { 3783 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3784 std::string ex(str, iter.base()); 3785 assert(ex == "*******************+1e+09"); 3786 assert(ios.width() == 0); 3787 } 3788 ios.width(25); 3789 internal(ios); 3790 { 3791 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3792 std::string ex(str, iter.base()); 3793 assert(ex == "+*******************1e+09"); 3794 assert(ios.width() == 0); 3795 } 3796 } 3797 ios.imbue(lg); 3798 { 3799 ios.width(0); 3800 { 3801 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3802 std::string ex(str, iter.base()); 3803 assert(ex == "+1e+09"); 3804 assert(ios.width() == 0); 3805 } 3806 ios.width(25); 3807 left(ios); 3808 { 3809 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3810 std::string ex(str, iter.base()); 3811 assert(ex == "+1e+09*******************"); 3812 assert(ios.width() == 0); 3813 } 3814 ios.width(25); 3815 right(ios); 3816 { 3817 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3818 std::string ex(str, iter.base()); 3819 assert(ex == "*******************+1e+09"); 3820 assert(ios.width() == 0); 3821 } 3822 ios.width(25); 3823 internal(ios); 3824 { 3825 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3826 std::string ex(str, iter.base()); 3827 assert(ex == "+*******************1e+09"); 3828 assert(ios.width() == 0); 3829 } 3830 } 3831 } 3832 showpoint(ios); 3833 { 3834 ios.imbue(lc); 3835 { 3836 ios.width(0); 3837 { 3838 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3839 std::string ex(str, iter.base()); 3840 assert(ex == "+1.e+09"); 3841 assert(ios.width() == 0); 3842 } 3843 ios.width(25); 3844 left(ios); 3845 { 3846 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3847 std::string ex(str, iter.base()); 3848 assert(ex == "+1.e+09******************"); 3849 assert(ios.width() == 0); 3850 } 3851 ios.width(25); 3852 right(ios); 3853 { 3854 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3855 std::string ex(str, iter.base()); 3856 assert(ex == "******************+1.e+09"); 3857 assert(ios.width() == 0); 3858 } 3859 ios.width(25); 3860 internal(ios); 3861 { 3862 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3863 std::string ex(str, iter.base()); 3864 assert(ex == "+******************1.e+09"); 3865 assert(ios.width() == 0); 3866 } 3867 } 3868 ios.imbue(lg); 3869 { 3870 ios.width(0); 3871 { 3872 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3873 std::string ex(str, iter.base()); 3874 assert(ex == "+1;e+09"); 3875 assert(ios.width() == 0); 3876 } 3877 ios.width(25); 3878 left(ios); 3879 { 3880 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3881 std::string ex(str, iter.base()); 3882 assert(ex == "+1;e+09******************"); 3883 assert(ios.width() == 0); 3884 } 3885 ios.width(25); 3886 right(ios); 3887 { 3888 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3889 std::string ex(str, iter.base()); 3890 assert(ex == "******************+1;e+09"); 3891 assert(ios.width() == 0); 3892 } 3893 ios.width(25); 3894 internal(ios); 3895 { 3896 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3897 std::string ex(str, iter.base()); 3898 assert(ex == "+******************1;e+09"); 3899 assert(ios.width() == 0); 3900 } 3901 } 3902 } 3903 } 3904 } 3905 uppercase(ios); 3906 { 3907 noshowpos(ios); 3908 { 3909 noshowpoint(ios); 3910 { 3911 ios.imbue(lc); 3912 { 3913 ios.width(0); 3914 { 3915 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3916 std::string ex(str, iter.base()); 3917 assert(ex == "1E+09"); 3918 assert(ios.width() == 0); 3919 } 3920 ios.width(25); 3921 left(ios); 3922 { 3923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3924 std::string ex(str, iter.base()); 3925 assert(ex == "1E+09********************"); 3926 assert(ios.width() == 0); 3927 } 3928 ios.width(25); 3929 right(ios); 3930 { 3931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3932 std::string ex(str, iter.base()); 3933 assert(ex == "********************1E+09"); 3934 assert(ios.width() == 0); 3935 } 3936 ios.width(25); 3937 internal(ios); 3938 { 3939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3940 std::string ex(str, iter.base()); 3941 assert(ex == "********************1E+09"); 3942 assert(ios.width() == 0); 3943 } 3944 } 3945 ios.imbue(lg); 3946 { 3947 ios.width(0); 3948 { 3949 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3950 std::string ex(str, iter.base()); 3951 assert(ex == "1E+09"); 3952 assert(ios.width() == 0); 3953 } 3954 ios.width(25); 3955 left(ios); 3956 { 3957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3958 std::string ex(str, iter.base()); 3959 assert(ex == "1E+09********************"); 3960 assert(ios.width() == 0); 3961 } 3962 ios.width(25); 3963 right(ios); 3964 { 3965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3966 std::string ex(str, iter.base()); 3967 assert(ex == "********************1E+09"); 3968 assert(ios.width() == 0); 3969 } 3970 ios.width(25); 3971 internal(ios); 3972 { 3973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3974 std::string ex(str, iter.base()); 3975 assert(ex == "********************1E+09"); 3976 assert(ios.width() == 0); 3977 } 3978 } 3979 } 3980 showpoint(ios); 3981 { 3982 ios.imbue(lc); 3983 { 3984 ios.width(0); 3985 { 3986 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3987 std::string ex(str, iter.base()); 3988 assert(ex == "1.E+09"); 3989 assert(ios.width() == 0); 3990 } 3991 ios.width(25); 3992 left(ios); 3993 { 3994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 3995 std::string ex(str, iter.base()); 3996 assert(ex == "1.E+09*******************"); 3997 assert(ios.width() == 0); 3998 } 3999 ios.width(25); 4000 right(ios); 4001 { 4002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4003 std::string ex(str, iter.base()); 4004 assert(ex == "*******************1.E+09"); 4005 assert(ios.width() == 0); 4006 } 4007 ios.width(25); 4008 internal(ios); 4009 { 4010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4011 std::string ex(str, iter.base()); 4012 assert(ex == "*******************1.E+09"); 4013 assert(ios.width() == 0); 4014 } 4015 } 4016 ios.imbue(lg); 4017 { 4018 ios.width(0); 4019 { 4020 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4021 std::string ex(str, iter.base()); 4022 assert(ex == "1;E+09"); 4023 assert(ios.width() == 0); 4024 } 4025 ios.width(25); 4026 left(ios); 4027 { 4028 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4029 std::string ex(str, iter.base()); 4030 assert(ex == "1;E+09*******************"); 4031 assert(ios.width() == 0); 4032 } 4033 ios.width(25); 4034 right(ios); 4035 { 4036 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4037 std::string ex(str, iter.base()); 4038 assert(ex == "*******************1;E+09"); 4039 assert(ios.width() == 0); 4040 } 4041 ios.width(25); 4042 internal(ios); 4043 { 4044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4045 std::string ex(str, iter.base()); 4046 assert(ex == "*******************1;E+09"); 4047 assert(ios.width() == 0); 4048 } 4049 } 4050 } 4051 } 4052 showpos(ios); 4053 { 4054 noshowpoint(ios); 4055 { 4056 ios.imbue(lc); 4057 { 4058 ios.width(0); 4059 { 4060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4061 std::string ex(str, iter.base()); 4062 assert(ex == "+1E+09"); 4063 assert(ios.width() == 0); 4064 } 4065 ios.width(25); 4066 left(ios); 4067 { 4068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4069 std::string ex(str, iter.base()); 4070 assert(ex == "+1E+09*******************"); 4071 assert(ios.width() == 0); 4072 } 4073 ios.width(25); 4074 right(ios); 4075 { 4076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4077 std::string ex(str, iter.base()); 4078 assert(ex == "*******************+1E+09"); 4079 assert(ios.width() == 0); 4080 } 4081 ios.width(25); 4082 internal(ios); 4083 { 4084 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4085 std::string ex(str, iter.base()); 4086 assert(ex == "+*******************1E+09"); 4087 assert(ios.width() == 0); 4088 } 4089 } 4090 ios.imbue(lg); 4091 { 4092 ios.width(0); 4093 { 4094 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4095 std::string ex(str, iter.base()); 4096 assert(ex == "+1E+09"); 4097 assert(ios.width() == 0); 4098 } 4099 ios.width(25); 4100 left(ios); 4101 { 4102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4103 std::string ex(str, iter.base()); 4104 assert(ex == "+1E+09*******************"); 4105 assert(ios.width() == 0); 4106 } 4107 ios.width(25); 4108 right(ios); 4109 { 4110 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4111 std::string ex(str, iter.base()); 4112 assert(ex == "*******************+1E+09"); 4113 assert(ios.width() == 0); 4114 } 4115 ios.width(25); 4116 internal(ios); 4117 { 4118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4119 std::string ex(str, iter.base()); 4120 assert(ex == "+*******************1E+09"); 4121 assert(ios.width() == 0); 4122 } 4123 } 4124 } 4125 showpoint(ios); 4126 { 4127 ios.imbue(lc); 4128 { 4129 ios.width(0); 4130 { 4131 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4132 std::string ex(str, iter.base()); 4133 assert(ex == "+1.E+09"); 4134 assert(ios.width() == 0); 4135 } 4136 ios.width(25); 4137 left(ios); 4138 { 4139 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4140 std::string ex(str, iter.base()); 4141 assert(ex == "+1.E+09******************"); 4142 assert(ios.width() == 0); 4143 } 4144 ios.width(25); 4145 right(ios); 4146 { 4147 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4148 std::string ex(str, iter.base()); 4149 assert(ex == "******************+1.E+09"); 4150 assert(ios.width() == 0); 4151 } 4152 ios.width(25); 4153 internal(ios); 4154 { 4155 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4156 std::string ex(str, iter.base()); 4157 assert(ex == "+******************1.E+09"); 4158 assert(ios.width() == 0); 4159 } 4160 } 4161 ios.imbue(lg); 4162 { 4163 ios.width(0); 4164 { 4165 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4166 std::string ex(str, iter.base()); 4167 assert(ex == "+1;E+09"); 4168 assert(ios.width() == 0); 4169 } 4170 ios.width(25); 4171 left(ios); 4172 { 4173 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4174 std::string ex(str, iter.base()); 4175 assert(ex == "+1;E+09******************"); 4176 assert(ios.width() == 0); 4177 } 4178 ios.width(25); 4179 right(ios); 4180 { 4181 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4182 std::string ex(str, iter.base()); 4183 assert(ex == "******************+1;E+09"); 4184 assert(ios.width() == 0); 4185 } 4186 ios.width(25); 4187 internal(ios); 4188 { 4189 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4190 std::string ex(str, iter.base()); 4191 assert(ex == "+******************1;E+09"); 4192 assert(ios.width() == 0); 4193 } 4194 } 4195 } 4196 } 4197 } 4198 } 4199 ios.precision(6); 4200 { 4201 nouppercase(ios); 4202 { 4203 noshowpos(ios); 4204 { 4205 noshowpoint(ios); 4206 { 4207 ios.imbue(lc); 4208 { 4209 ios.width(0); 4210 { 4211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4212 std::string ex(str, iter.base()); 4213 assert(ex == "1.23457e+09"); 4214 assert(ios.width() == 0); 4215 } 4216 ios.width(25); 4217 left(ios); 4218 { 4219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4220 std::string ex(str, iter.base()); 4221 assert(ex == "1.23457e+09**************"); 4222 assert(ios.width() == 0); 4223 } 4224 ios.width(25); 4225 right(ios); 4226 { 4227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4228 std::string ex(str, iter.base()); 4229 assert(ex == "**************1.23457e+09"); 4230 assert(ios.width() == 0); 4231 } 4232 ios.width(25); 4233 internal(ios); 4234 { 4235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4236 std::string ex(str, iter.base()); 4237 assert(ex == "**************1.23457e+09"); 4238 assert(ios.width() == 0); 4239 } 4240 } 4241 ios.imbue(lg); 4242 { 4243 ios.width(0); 4244 { 4245 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4246 std::string ex(str, iter.base()); 4247 assert(ex == "1;23457e+09"); 4248 assert(ios.width() == 0); 4249 } 4250 ios.width(25); 4251 left(ios); 4252 { 4253 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4254 std::string ex(str, iter.base()); 4255 assert(ex == "1;23457e+09**************"); 4256 assert(ios.width() == 0); 4257 } 4258 ios.width(25); 4259 right(ios); 4260 { 4261 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4262 std::string ex(str, iter.base()); 4263 assert(ex == "**************1;23457e+09"); 4264 assert(ios.width() == 0); 4265 } 4266 ios.width(25); 4267 internal(ios); 4268 { 4269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4270 std::string ex(str, iter.base()); 4271 assert(ex == "**************1;23457e+09"); 4272 assert(ios.width() == 0); 4273 } 4274 } 4275 } 4276 showpoint(ios); 4277 { 4278 ios.imbue(lc); 4279 { 4280 ios.width(0); 4281 { 4282 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4283 std::string ex(str, iter.base()); 4284 assert(ex == "1.23457e+09"); 4285 assert(ios.width() == 0); 4286 } 4287 ios.width(25); 4288 left(ios); 4289 { 4290 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4291 std::string ex(str, iter.base()); 4292 assert(ex == "1.23457e+09**************"); 4293 assert(ios.width() == 0); 4294 } 4295 ios.width(25); 4296 right(ios); 4297 { 4298 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4299 std::string ex(str, iter.base()); 4300 assert(ex == "**************1.23457e+09"); 4301 assert(ios.width() == 0); 4302 } 4303 ios.width(25); 4304 internal(ios); 4305 { 4306 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4307 std::string ex(str, iter.base()); 4308 assert(ex == "**************1.23457e+09"); 4309 assert(ios.width() == 0); 4310 } 4311 } 4312 ios.imbue(lg); 4313 { 4314 ios.width(0); 4315 { 4316 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4317 std::string ex(str, iter.base()); 4318 assert(ex == "1;23457e+09"); 4319 assert(ios.width() == 0); 4320 } 4321 ios.width(25); 4322 left(ios); 4323 { 4324 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4325 std::string ex(str, iter.base()); 4326 assert(ex == "1;23457e+09**************"); 4327 assert(ios.width() == 0); 4328 } 4329 ios.width(25); 4330 right(ios); 4331 { 4332 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4333 std::string ex(str, iter.base()); 4334 assert(ex == "**************1;23457e+09"); 4335 assert(ios.width() == 0); 4336 } 4337 ios.width(25); 4338 internal(ios); 4339 { 4340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4341 std::string ex(str, iter.base()); 4342 assert(ex == "**************1;23457e+09"); 4343 assert(ios.width() == 0); 4344 } 4345 } 4346 } 4347 } 4348 showpos(ios); 4349 { 4350 noshowpoint(ios); 4351 { 4352 ios.imbue(lc); 4353 { 4354 ios.width(0); 4355 { 4356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4357 std::string ex(str, iter.base()); 4358 assert(ex == "+1.23457e+09"); 4359 assert(ios.width() == 0); 4360 } 4361 ios.width(25); 4362 left(ios); 4363 { 4364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4365 std::string ex(str, iter.base()); 4366 assert(ex == "+1.23457e+09*************"); 4367 assert(ios.width() == 0); 4368 } 4369 ios.width(25); 4370 right(ios); 4371 { 4372 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4373 std::string ex(str, iter.base()); 4374 assert(ex == "*************+1.23457e+09"); 4375 assert(ios.width() == 0); 4376 } 4377 ios.width(25); 4378 internal(ios); 4379 { 4380 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4381 std::string ex(str, iter.base()); 4382 assert(ex == "+*************1.23457e+09"); 4383 assert(ios.width() == 0); 4384 } 4385 } 4386 ios.imbue(lg); 4387 { 4388 ios.width(0); 4389 { 4390 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4391 std::string ex(str, iter.base()); 4392 assert(ex == "+1;23457e+09"); 4393 assert(ios.width() == 0); 4394 } 4395 ios.width(25); 4396 left(ios); 4397 { 4398 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4399 std::string ex(str, iter.base()); 4400 assert(ex == "+1;23457e+09*************"); 4401 assert(ios.width() == 0); 4402 } 4403 ios.width(25); 4404 right(ios); 4405 { 4406 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4407 std::string ex(str, iter.base()); 4408 assert(ex == "*************+1;23457e+09"); 4409 assert(ios.width() == 0); 4410 } 4411 ios.width(25); 4412 internal(ios); 4413 { 4414 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4415 std::string ex(str, iter.base()); 4416 assert(ex == "+*************1;23457e+09"); 4417 assert(ios.width() == 0); 4418 } 4419 } 4420 } 4421 showpoint(ios); 4422 { 4423 ios.imbue(lc); 4424 { 4425 ios.width(0); 4426 { 4427 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4428 std::string ex(str, iter.base()); 4429 assert(ex == "+1.23457e+09"); 4430 assert(ios.width() == 0); 4431 } 4432 ios.width(25); 4433 left(ios); 4434 { 4435 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4436 std::string ex(str, iter.base()); 4437 assert(ex == "+1.23457e+09*************"); 4438 assert(ios.width() == 0); 4439 } 4440 ios.width(25); 4441 right(ios); 4442 { 4443 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4444 std::string ex(str, iter.base()); 4445 assert(ex == "*************+1.23457e+09"); 4446 assert(ios.width() == 0); 4447 } 4448 ios.width(25); 4449 internal(ios); 4450 { 4451 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4452 std::string ex(str, iter.base()); 4453 assert(ex == "+*************1.23457e+09"); 4454 assert(ios.width() == 0); 4455 } 4456 } 4457 ios.imbue(lg); 4458 { 4459 ios.width(0); 4460 { 4461 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4462 std::string ex(str, iter.base()); 4463 assert(ex == "+1;23457e+09"); 4464 assert(ios.width() == 0); 4465 } 4466 ios.width(25); 4467 left(ios); 4468 { 4469 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4470 std::string ex(str, iter.base()); 4471 assert(ex == "+1;23457e+09*************"); 4472 assert(ios.width() == 0); 4473 } 4474 ios.width(25); 4475 right(ios); 4476 { 4477 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4478 std::string ex(str, iter.base()); 4479 assert(ex == "*************+1;23457e+09"); 4480 assert(ios.width() == 0); 4481 } 4482 ios.width(25); 4483 internal(ios); 4484 { 4485 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4486 std::string ex(str, iter.base()); 4487 assert(ex == "+*************1;23457e+09"); 4488 assert(ios.width() == 0); 4489 } 4490 } 4491 } 4492 } 4493 } 4494 uppercase(ios); 4495 { 4496 noshowpos(ios); 4497 { 4498 noshowpoint(ios); 4499 { 4500 ios.imbue(lc); 4501 { 4502 ios.width(0); 4503 { 4504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4505 std::string ex(str, iter.base()); 4506 assert(ex == "1.23457E+09"); 4507 assert(ios.width() == 0); 4508 } 4509 ios.width(25); 4510 left(ios); 4511 { 4512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4513 std::string ex(str, iter.base()); 4514 assert(ex == "1.23457E+09**************"); 4515 assert(ios.width() == 0); 4516 } 4517 ios.width(25); 4518 right(ios); 4519 { 4520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4521 std::string ex(str, iter.base()); 4522 assert(ex == "**************1.23457E+09"); 4523 assert(ios.width() == 0); 4524 } 4525 ios.width(25); 4526 internal(ios); 4527 { 4528 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4529 std::string ex(str, iter.base()); 4530 assert(ex == "**************1.23457E+09"); 4531 assert(ios.width() == 0); 4532 } 4533 } 4534 ios.imbue(lg); 4535 { 4536 ios.width(0); 4537 { 4538 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4539 std::string ex(str, iter.base()); 4540 assert(ex == "1;23457E+09"); 4541 assert(ios.width() == 0); 4542 } 4543 ios.width(25); 4544 left(ios); 4545 { 4546 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4547 std::string ex(str, iter.base()); 4548 assert(ex == "1;23457E+09**************"); 4549 assert(ios.width() == 0); 4550 } 4551 ios.width(25); 4552 right(ios); 4553 { 4554 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4555 std::string ex(str, iter.base()); 4556 assert(ex == "**************1;23457E+09"); 4557 assert(ios.width() == 0); 4558 } 4559 ios.width(25); 4560 internal(ios); 4561 { 4562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4563 std::string ex(str, iter.base()); 4564 assert(ex == "**************1;23457E+09"); 4565 assert(ios.width() == 0); 4566 } 4567 } 4568 } 4569 showpoint(ios); 4570 { 4571 ios.imbue(lc); 4572 { 4573 ios.width(0); 4574 { 4575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4576 std::string ex(str, iter.base()); 4577 assert(ex == "1.23457E+09"); 4578 assert(ios.width() == 0); 4579 } 4580 ios.width(25); 4581 left(ios); 4582 { 4583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4584 std::string ex(str, iter.base()); 4585 assert(ex == "1.23457E+09**************"); 4586 assert(ios.width() == 0); 4587 } 4588 ios.width(25); 4589 right(ios); 4590 { 4591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4592 std::string ex(str, iter.base()); 4593 assert(ex == "**************1.23457E+09"); 4594 assert(ios.width() == 0); 4595 } 4596 ios.width(25); 4597 internal(ios); 4598 { 4599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4600 std::string ex(str, iter.base()); 4601 assert(ex == "**************1.23457E+09"); 4602 assert(ios.width() == 0); 4603 } 4604 } 4605 ios.imbue(lg); 4606 { 4607 ios.width(0); 4608 { 4609 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4610 std::string ex(str, iter.base()); 4611 assert(ex == "1;23457E+09"); 4612 assert(ios.width() == 0); 4613 } 4614 ios.width(25); 4615 left(ios); 4616 { 4617 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4618 std::string ex(str, iter.base()); 4619 assert(ex == "1;23457E+09**************"); 4620 assert(ios.width() == 0); 4621 } 4622 ios.width(25); 4623 right(ios); 4624 { 4625 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4626 std::string ex(str, iter.base()); 4627 assert(ex == "**************1;23457E+09"); 4628 assert(ios.width() == 0); 4629 } 4630 ios.width(25); 4631 internal(ios); 4632 { 4633 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4634 std::string ex(str, iter.base()); 4635 assert(ex == "**************1;23457E+09"); 4636 assert(ios.width() == 0); 4637 } 4638 } 4639 } 4640 } 4641 showpos(ios); 4642 { 4643 noshowpoint(ios); 4644 { 4645 ios.imbue(lc); 4646 { 4647 ios.width(0); 4648 { 4649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4650 std::string ex(str, iter.base()); 4651 assert(ex == "+1.23457E+09"); 4652 assert(ios.width() == 0); 4653 } 4654 ios.width(25); 4655 left(ios); 4656 { 4657 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4658 std::string ex(str, iter.base()); 4659 assert(ex == "+1.23457E+09*************"); 4660 assert(ios.width() == 0); 4661 } 4662 ios.width(25); 4663 right(ios); 4664 { 4665 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4666 std::string ex(str, iter.base()); 4667 assert(ex == "*************+1.23457E+09"); 4668 assert(ios.width() == 0); 4669 } 4670 ios.width(25); 4671 internal(ios); 4672 { 4673 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4674 std::string ex(str, iter.base()); 4675 assert(ex == "+*************1.23457E+09"); 4676 assert(ios.width() == 0); 4677 } 4678 } 4679 ios.imbue(lg); 4680 { 4681 ios.width(0); 4682 { 4683 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4684 std::string ex(str, iter.base()); 4685 assert(ex == "+1;23457E+09"); 4686 assert(ios.width() == 0); 4687 } 4688 ios.width(25); 4689 left(ios); 4690 { 4691 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4692 std::string ex(str, iter.base()); 4693 assert(ex == "+1;23457E+09*************"); 4694 assert(ios.width() == 0); 4695 } 4696 ios.width(25); 4697 right(ios); 4698 { 4699 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4700 std::string ex(str, iter.base()); 4701 assert(ex == "*************+1;23457E+09"); 4702 assert(ios.width() == 0); 4703 } 4704 ios.width(25); 4705 internal(ios); 4706 { 4707 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4708 std::string ex(str, iter.base()); 4709 assert(ex == "+*************1;23457E+09"); 4710 assert(ios.width() == 0); 4711 } 4712 } 4713 } 4714 showpoint(ios); 4715 { 4716 ios.imbue(lc); 4717 { 4718 ios.width(0); 4719 { 4720 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4721 std::string ex(str, iter.base()); 4722 assert(ex == "+1.23457E+09"); 4723 assert(ios.width() == 0); 4724 } 4725 ios.width(25); 4726 left(ios); 4727 { 4728 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4729 std::string ex(str, iter.base()); 4730 assert(ex == "+1.23457E+09*************"); 4731 assert(ios.width() == 0); 4732 } 4733 ios.width(25); 4734 right(ios); 4735 { 4736 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4737 std::string ex(str, iter.base()); 4738 assert(ex == "*************+1.23457E+09"); 4739 assert(ios.width() == 0); 4740 } 4741 ios.width(25); 4742 internal(ios); 4743 { 4744 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4745 std::string ex(str, iter.base()); 4746 assert(ex == "+*************1.23457E+09"); 4747 assert(ios.width() == 0); 4748 } 4749 } 4750 ios.imbue(lg); 4751 { 4752 ios.width(0); 4753 { 4754 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4755 std::string ex(str, iter.base()); 4756 assert(ex == "+1;23457E+09"); 4757 assert(ios.width() == 0); 4758 } 4759 ios.width(25); 4760 left(ios); 4761 { 4762 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4763 std::string ex(str, iter.base()); 4764 assert(ex == "+1;23457E+09*************"); 4765 assert(ios.width() == 0); 4766 } 4767 ios.width(25); 4768 right(ios); 4769 { 4770 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4771 std::string ex(str, iter.base()); 4772 assert(ex == "*************+1;23457E+09"); 4773 assert(ios.width() == 0); 4774 } 4775 ios.width(25); 4776 internal(ios); 4777 { 4778 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4779 std::string ex(str, iter.base()); 4780 assert(ex == "+*************1;23457E+09"); 4781 assert(ios.width() == 0); 4782 } 4783 } 4784 } 4785 } 4786 } 4787 } 4788 ios.precision(16); 4789 { 4790 nouppercase(ios); 4791 { 4792 noshowpos(ios); 4793 { 4794 noshowpoint(ios); 4795 { 4796 ios.imbue(lc); 4797 { 4798 ios.width(0); 4799 { 4800 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4801 std::string ex(str, iter.base()); 4802 assert(ex == "1234567890.125"); 4803 assert(ios.width() == 0); 4804 } 4805 ios.width(25); 4806 left(ios); 4807 { 4808 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4809 std::string ex(str, iter.base()); 4810 assert(ex == "1234567890.125***********"); 4811 assert(ios.width() == 0); 4812 } 4813 ios.width(25); 4814 right(ios); 4815 { 4816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4817 std::string ex(str, iter.base()); 4818 assert(ex == "***********1234567890.125"); 4819 assert(ios.width() == 0); 4820 } 4821 ios.width(25); 4822 internal(ios); 4823 { 4824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4825 std::string ex(str, iter.base()); 4826 assert(ex == "***********1234567890.125"); 4827 assert(ios.width() == 0); 4828 } 4829 } 4830 ios.imbue(lg); 4831 { 4832 ios.width(0); 4833 { 4834 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4835 std::string ex(str, iter.base()); 4836 assert(ex == "1_234_567_89_0;125"); 4837 assert(ios.width() == 0); 4838 } 4839 ios.width(25); 4840 left(ios); 4841 { 4842 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4843 std::string ex(str, iter.base()); 4844 assert(ex == "1_234_567_89_0;125*******"); 4845 assert(ios.width() == 0); 4846 } 4847 ios.width(25); 4848 right(ios); 4849 { 4850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4851 std::string ex(str, iter.base()); 4852 assert(ex == "*******1_234_567_89_0;125"); 4853 assert(ios.width() == 0); 4854 } 4855 ios.width(25); 4856 internal(ios); 4857 { 4858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4859 std::string ex(str, iter.base()); 4860 assert(ex == "*******1_234_567_89_0;125"); 4861 assert(ios.width() == 0); 4862 } 4863 } 4864 } 4865 showpoint(ios); 4866 { 4867 ios.imbue(lc); 4868 { 4869 ios.width(0); 4870 { 4871 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4872 std::string ex(str, iter.base()); 4873 assert(ex == "1234567890.125000"); 4874 assert(ios.width() == 0); 4875 } 4876 ios.width(25); 4877 left(ios); 4878 { 4879 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4880 std::string ex(str, iter.base()); 4881 assert(ex == "1234567890.125000********"); 4882 assert(ios.width() == 0); 4883 } 4884 ios.width(25); 4885 right(ios); 4886 { 4887 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4888 std::string ex(str, iter.base()); 4889 assert(ex == "********1234567890.125000"); 4890 assert(ios.width() == 0); 4891 } 4892 ios.width(25); 4893 internal(ios); 4894 { 4895 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4896 std::string ex(str, iter.base()); 4897 assert(ex == "********1234567890.125000"); 4898 assert(ios.width() == 0); 4899 } 4900 } 4901 ios.imbue(lg); 4902 { 4903 ios.width(0); 4904 { 4905 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4906 std::string ex(str, iter.base()); 4907 assert(ex == "1_234_567_89_0;125000"); 4908 assert(ios.width() == 0); 4909 } 4910 ios.width(25); 4911 left(ios); 4912 { 4913 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4914 std::string ex(str, iter.base()); 4915 assert(ex == "1_234_567_89_0;125000****"); 4916 assert(ios.width() == 0); 4917 } 4918 ios.width(25); 4919 right(ios); 4920 { 4921 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4922 std::string ex(str, iter.base()); 4923 assert(ex == "****1_234_567_89_0;125000"); 4924 assert(ios.width() == 0); 4925 } 4926 ios.width(25); 4927 internal(ios); 4928 { 4929 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4930 std::string ex(str, iter.base()); 4931 assert(ex == "****1_234_567_89_0;125000"); 4932 assert(ios.width() == 0); 4933 } 4934 } 4935 } 4936 } 4937 showpos(ios); 4938 { 4939 noshowpoint(ios); 4940 { 4941 ios.imbue(lc); 4942 { 4943 ios.width(0); 4944 { 4945 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4946 std::string ex(str, iter.base()); 4947 assert(ex == "+1234567890.125"); 4948 assert(ios.width() == 0); 4949 } 4950 ios.width(25); 4951 left(ios); 4952 { 4953 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4954 std::string ex(str, iter.base()); 4955 assert(ex == "+1234567890.125**********"); 4956 assert(ios.width() == 0); 4957 } 4958 ios.width(25); 4959 right(ios); 4960 { 4961 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4962 std::string ex(str, iter.base()); 4963 assert(ex == "**********+1234567890.125"); 4964 assert(ios.width() == 0); 4965 } 4966 ios.width(25); 4967 internal(ios); 4968 { 4969 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4970 std::string ex(str, iter.base()); 4971 assert(ex == "+**********1234567890.125"); 4972 assert(ios.width() == 0); 4973 } 4974 } 4975 ios.imbue(lg); 4976 { 4977 ios.width(0); 4978 { 4979 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4980 std::string ex(str, iter.base()); 4981 assert(ex == "+1_234_567_89_0;125"); 4982 assert(ios.width() == 0); 4983 } 4984 ios.width(25); 4985 left(ios); 4986 { 4987 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4988 std::string ex(str, iter.base()); 4989 assert(ex == "+1_234_567_89_0;125******"); 4990 assert(ios.width() == 0); 4991 } 4992 ios.width(25); 4993 right(ios); 4994 { 4995 iter = f.put(output_iterator<char*>(str), ios, '*', v); 4996 std::string ex(str, iter.base()); 4997 assert(ex == "******+1_234_567_89_0;125"); 4998 assert(ios.width() == 0); 4999 } 5000 ios.width(25); 5001 internal(ios); 5002 { 5003 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5004 std::string ex(str, iter.base()); 5005 assert(ex == "+******1_234_567_89_0;125"); 5006 assert(ios.width() == 0); 5007 } 5008 } 5009 } 5010 showpoint(ios); 5011 { 5012 ios.imbue(lc); 5013 { 5014 ios.width(0); 5015 { 5016 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5017 std::string ex(str, iter.base()); 5018 assert(ex == "+1234567890.125000"); 5019 assert(ios.width() == 0); 5020 } 5021 ios.width(25); 5022 left(ios); 5023 { 5024 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5025 std::string ex(str, iter.base()); 5026 assert(ex == "+1234567890.125000*******"); 5027 assert(ios.width() == 0); 5028 } 5029 ios.width(25); 5030 right(ios); 5031 { 5032 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5033 std::string ex(str, iter.base()); 5034 assert(ex == "*******+1234567890.125000"); 5035 assert(ios.width() == 0); 5036 } 5037 ios.width(25); 5038 internal(ios); 5039 { 5040 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5041 std::string ex(str, iter.base()); 5042 assert(ex == "+*******1234567890.125000"); 5043 assert(ios.width() == 0); 5044 } 5045 } 5046 ios.imbue(lg); 5047 { 5048 ios.width(0); 5049 { 5050 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5051 std::string ex(str, iter.base()); 5052 assert(ex == "+1_234_567_89_0;125000"); 5053 assert(ios.width() == 0); 5054 } 5055 ios.width(25); 5056 left(ios); 5057 { 5058 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5059 std::string ex(str, iter.base()); 5060 assert(ex == "+1_234_567_89_0;125000***"); 5061 assert(ios.width() == 0); 5062 } 5063 ios.width(25); 5064 right(ios); 5065 { 5066 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5067 std::string ex(str, iter.base()); 5068 assert(ex == "***+1_234_567_89_0;125000"); 5069 assert(ios.width() == 0); 5070 } 5071 ios.width(25); 5072 internal(ios); 5073 { 5074 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5075 std::string ex(str, iter.base()); 5076 assert(ex == "+***1_234_567_89_0;125000"); 5077 assert(ios.width() == 0); 5078 } 5079 } 5080 } 5081 } 5082 } 5083 uppercase(ios); 5084 { 5085 noshowpos(ios); 5086 { 5087 noshowpoint(ios); 5088 { 5089 ios.imbue(lc); 5090 { 5091 ios.width(0); 5092 { 5093 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5094 std::string ex(str, iter.base()); 5095 assert(ex == "1234567890.125"); 5096 assert(ios.width() == 0); 5097 } 5098 ios.width(25); 5099 left(ios); 5100 { 5101 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5102 std::string ex(str, iter.base()); 5103 assert(ex == "1234567890.125***********"); 5104 assert(ios.width() == 0); 5105 } 5106 ios.width(25); 5107 right(ios); 5108 { 5109 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5110 std::string ex(str, iter.base()); 5111 assert(ex == "***********1234567890.125"); 5112 assert(ios.width() == 0); 5113 } 5114 ios.width(25); 5115 internal(ios); 5116 { 5117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5118 std::string ex(str, iter.base()); 5119 assert(ex == "***********1234567890.125"); 5120 assert(ios.width() == 0); 5121 } 5122 } 5123 ios.imbue(lg); 5124 { 5125 ios.width(0); 5126 { 5127 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5128 std::string ex(str, iter.base()); 5129 assert(ex == "1_234_567_89_0;125"); 5130 assert(ios.width() == 0); 5131 } 5132 ios.width(25); 5133 left(ios); 5134 { 5135 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5136 std::string ex(str, iter.base()); 5137 assert(ex == "1_234_567_89_0;125*******"); 5138 assert(ios.width() == 0); 5139 } 5140 ios.width(25); 5141 right(ios); 5142 { 5143 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5144 std::string ex(str, iter.base()); 5145 assert(ex == "*******1_234_567_89_0;125"); 5146 assert(ios.width() == 0); 5147 } 5148 ios.width(25); 5149 internal(ios); 5150 { 5151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5152 std::string ex(str, iter.base()); 5153 assert(ex == "*******1_234_567_89_0;125"); 5154 assert(ios.width() == 0); 5155 } 5156 } 5157 } 5158 showpoint(ios); 5159 { 5160 ios.imbue(lc); 5161 { 5162 ios.width(0); 5163 { 5164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5165 std::string ex(str, iter.base()); 5166 assert(ex == "1234567890.125000"); 5167 assert(ios.width() == 0); 5168 } 5169 ios.width(25); 5170 left(ios); 5171 { 5172 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5173 std::string ex(str, iter.base()); 5174 assert(ex == "1234567890.125000********"); 5175 assert(ios.width() == 0); 5176 } 5177 ios.width(25); 5178 right(ios); 5179 { 5180 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5181 std::string ex(str, iter.base()); 5182 assert(ex == "********1234567890.125000"); 5183 assert(ios.width() == 0); 5184 } 5185 ios.width(25); 5186 internal(ios); 5187 { 5188 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5189 std::string ex(str, iter.base()); 5190 assert(ex == "********1234567890.125000"); 5191 assert(ios.width() == 0); 5192 } 5193 } 5194 ios.imbue(lg); 5195 { 5196 ios.width(0); 5197 { 5198 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5199 std::string ex(str, iter.base()); 5200 assert(ex == "1_234_567_89_0;125000"); 5201 assert(ios.width() == 0); 5202 } 5203 ios.width(25); 5204 left(ios); 5205 { 5206 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5207 std::string ex(str, iter.base()); 5208 assert(ex == "1_234_567_89_0;125000****"); 5209 assert(ios.width() == 0); 5210 } 5211 ios.width(25); 5212 right(ios); 5213 { 5214 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5215 std::string ex(str, iter.base()); 5216 assert(ex == "****1_234_567_89_0;125000"); 5217 assert(ios.width() == 0); 5218 } 5219 ios.width(25); 5220 internal(ios); 5221 { 5222 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5223 std::string ex(str, iter.base()); 5224 assert(ex == "****1_234_567_89_0;125000"); 5225 assert(ios.width() == 0); 5226 } 5227 } 5228 } 5229 } 5230 showpos(ios); 5231 { 5232 noshowpoint(ios); 5233 { 5234 ios.imbue(lc); 5235 { 5236 ios.width(0); 5237 { 5238 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5239 std::string ex(str, iter.base()); 5240 assert(ex == "+1234567890.125"); 5241 assert(ios.width() == 0); 5242 } 5243 ios.width(25); 5244 left(ios); 5245 { 5246 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5247 std::string ex(str, iter.base()); 5248 assert(ex == "+1234567890.125**********"); 5249 assert(ios.width() == 0); 5250 } 5251 ios.width(25); 5252 right(ios); 5253 { 5254 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5255 std::string ex(str, iter.base()); 5256 assert(ex == "**********+1234567890.125"); 5257 assert(ios.width() == 0); 5258 } 5259 ios.width(25); 5260 internal(ios); 5261 { 5262 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5263 std::string ex(str, iter.base()); 5264 assert(ex == "+**********1234567890.125"); 5265 assert(ios.width() == 0); 5266 } 5267 } 5268 ios.imbue(lg); 5269 { 5270 ios.width(0); 5271 { 5272 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5273 std::string ex(str, iter.base()); 5274 assert(ex == "+1_234_567_89_0;125"); 5275 assert(ios.width() == 0); 5276 } 5277 ios.width(25); 5278 left(ios); 5279 { 5280 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5281 std::string ex(str, iter.base()); 5282 assert(ex == "+1_234_567_89_0;125******"); 5283 assert(ios.width() == 0); 5284 } 5285 ios.width(25); 5286 right(ios); 5287 { 5288 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5289 std::string ex(str, iter.base()); 5290 assert(ex == "******+1_234_567_89_0;125"); 5291 assert(ios.width() == 0); 5292 } 5293 ios.width(25); 5294 internal(ios); 5295 { 5296 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5297 std::string ex(str, iter.base()); 5298 assert(ex == "+******1_234_567_89_0;125"); 5299 assert(ios.width() == 0); 5300 } 5301 } 5302 } 5303 showpoint(ios); 5304 { 5305 ios.imbue(lc); 5306 { 5307 ios.width(0); 5308 { 5309 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5310 std::string ex(str, iter.base()); 5311 assert(ex == "+1234567890.125000"); 5312 assert(ios.width() == 0); 5313 } 5314 ios.width(25); 5315 left(ios); 5316 { 5317 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5318 std::string ex(str, iter.base()); 5319 assert(ex == "+1234567890.125000*******"); 5320 assert(ios.width() == 0); 5321 } 5322 ios.width(25); 5323 right(ios); 5324 { 5325 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5326 std::string ex(str, iter.base()); 5327 assert(ex == "*******+1234567890.125000"); 5328 assert(ios.width() == 0); 5329 } 5330 ios.width(25); 5331 internal(ios); 5332 { 5333 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5334 std::string ex(str, iter.base()); 5335 assert(ex == "+*******1234567890.125000"); 5336 assert(ios.width() == 0); 5337 } 5338 } 5339 ios.imbue(lg); 5340 { 5341 ios.width(0); 5342 { 5343 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5344 std::string ex(str, iter.base()); 5345 assert(ex == "+1_234_567_89_0;125000"); 5346 assert(ios.width() == 0); 5347 } 5348 ios.width(25); 5349 left(ios); 5350 { 5351 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5352 std::string ex(str, iter.base()); 5353 assert(ex == "+1_234_567_89_0;125000***"); 5354 assert(ios.width() == 0); 5355 } 5356 ios.width(25); 5357 right(ios); 5358 { 5359 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5360 std::string ex(str, iter.base()); 5361 assert(ex == "***+1_234_567_89_0;125000"); 5362 assert(ios.width() == 0); 5363 } 5364 ios.width(25); 5365 internal(ios); 5366 { 5367 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5368 std::string ex(str, iter.base()); 5369 assert(ex == "+***1_234_567_89_0;125000"); 5370 assert(ios.width() == 0); 5371 } 5372 } 5373 } 5374 } 5375 } 5376 } 5377 ios.precision(60); 5378 { 5379 nouppercase(ios); 5380 { 5381 noshowpos(ios); 5382 { 5383 noshowpoint(ios); 5384 { 5385 ios.imbue(lc); 5386 { 5387 ios.width(0); 5388 { 5389 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5390 std::string ex(str, iter.base()); 5391 assert(ex == "1234567890.125"); 5392 assert(ios.width() == 0); 5393 } 5394 ios.width(25); 5395 left(ios); 5396 { 5397 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5398 std::string ex(str, iter.base()); 5399 assert(ex == "1234567890.125***********"); 5400 assert(ios.width() == 0); 5401 } 5402 ios.width(25); 5403 right(ios); 5404 { 5405 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5406 std::string ex(str, iter.base()); 5407 assert(ex == "***********1234567890.125"); 5408 assert(ios.width() == 0); 5409 } 5410 ios.width(25); 5411 internal(ios); 5412 { 5413 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5414 std::string ex(str, iter.base()); 5415 assert(ex == "***********1234567890.125"); 5416 assert(ios.width() == 0); 5417 } 5418 } 5419 ios.imbue(lg); 5420 { 5421 ios.width(0); 5422 { 5423 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5424 std::string ex(str, iter.base()); 5425 assert(ex == "1_234_567_89_0;125"); 5426 assert(ios.width() == 0); 5427 } 5428 ios.width(25); 5429 left(ios); 5430 { 5431 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5432 std::string ex(str, iter.base()); 5433 assert(ex == "1_234_567_89_0;125*******"); 5434 assert(ios.width() == 0); 5435 } 5436 ios.width(25); 5437 right(ios); 5438 { 5439 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5440 std::string ex(str, iter.base()); 5441 assert(ex == "*******1_234_567_89_0;125"); 5442 assert(ios.width() == 0); 5443 } 5444 ios.width(25); 5445 internal(ios); 5446 { 5447 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5448 std::string ex(str, iter.base()); 5449 assert(ex == "*******1_234_567_89_0;125"); 5450 assert(ios.width() == 0); 5451 } 5452 } 5453 } 5454 showpoint(ios); 5455 { 5456 ios.imbue(lc); 5457 { 5458 ios.width(0); 5459 { 5460 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5461 std::string ex(str, iter.base()); 5462 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 5463 assert(ios.width() == 0); 5464 } 5465 ios.width(25); 5466 left(ios); 5467 { 5468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5469 std::string ex(str, iter.base()); 5470 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 5471 assert(ios.width() == 0); 5472 } 5473 ios.width(25); 5474 right(ios); 5475 { 5476 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5477 std::string ex(str, iter.base()); 5478 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 5479 assert(ios.width() == 0); 5480 } 5481 ios.width(25); 5482 internal(ios); 5483 { 5484 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5485 std::string ex(str, iter.base()); 5486 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 5487 assert(ios.width() == 0); 5488 } 5489 } 5490 ios.imbue(lg); 5491 { 5492 ios.width(0); 5493 { 5494 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5495 std::string ex(str, iter.base()); 5496 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5497 assert(ios.width() == 0); 5498 } 5499 ios.width(25); 5500 left(ios); 5501 { 5502 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5503 std::string ex(str, iter.base()); 5504 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5505 assert(ios.width() == 0); 5506 } 5507 ios.width(25); 5508 right(ios); 5509 { 5510 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5511 std::string ex(str, iter.base()); 5512 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5513 assert(ios.width() == 0); 5514 } 5515 ios.width(25); 5516 internal(ios); 5517 { 5518 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5519 std::string ex(str, iter.base()); 5520 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5521 assert(ios.width() == 0); 5522 } 5523 } 5524 } 5525 } 5526 showpos(ios); 5527 { 5528 noshowpoint(ios); 5529 { 5530 ios.imbue(lc); 5531 { 5532 ios.width(0); 5533 { 5534 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5535 std::string ex(str, iter.base()); 5536 assert(ex == "+1234567890.125"); 5537 assert(ios.width() == 0); 5538 } 5539 ios.width(25); 5540 left(ios); 5541 { 5542 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5543 std::string ex(str, iter.base()); 5544 assert(ex == "+1234567890.125**********"); 5545 assert(ios.width() == 0); 5546 } 5547 ios.width(25); 5548 right(ios); 5549 { 5550 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5551 std::string ex(str, iter.base()); 5552 assert(ex == "**********+1234567890.125"); 5553 assert(ios.width() == 0); 5554 } 5555 ios.width(25); 5556 internal(ios); 5557 { 5558 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5559 std::string ex(str, iter.base()); 5560 assert(ex == "+**********1234567890.125"); 5561 assert(ios.width() == 0); 5562 } 5563 } 5564 ios.imbue(lg); 5565 { 5566 ios.width(0); 5567 { 5568 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5569 std::string ex(str, iter.base()); 5570 assert(ex == "+1_234_567_89_0;125"); 5571 assert(ios.width() == 0); 5572 } 5573 ios.width(25); 5574 left(ios); 5575 { 5576 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5577 std::string ex(str, iter.base()); 5578 assert(ex == "+1_234_567_89_0;125******"); 5579 assert(ios.width() == 0); 5580 } 5581 ios.width(25); 5582 right(ios); 5583 { 5584 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5585 std::string ex(str, iter.base()); 5586 assert(ex == "******+1_234_567_89_0;125"); 5587 assert(ios.width() == 0); 5588 } 5589 ios.width(25); 5590 internal(ios); 5591 { 5592 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5593 std::string ex(str, iter.base()); 5594 assert(ex == "+******1_234_567_89_0;125"); 5595 assert(ios.width() == 0); 5596 } 5597 } 5598 } 5599 showpoint(ios); 5600 { 5601 ios.imbue(lc); 5602 { 5603 ios.width(0); 5604 { 5605 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5606 std::string ex(str, iter.base()); 5607 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 5608 assert(ios.width() == 0); 5609 } 5610 ios.width(25); 5611 left(ios); 5612 { 5613 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5614 std::string ex(str, iter.base()); 5615 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 5616 assert(ios.width() == 0); 5617 } 5618 ios.width(25); 5619 right(ios); 5620 { 5621 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5622 std::string ex(str, iter.base()); 5623 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 5624 assert(ios.width() == 0); 5625 } 5626 ios.width(25); 5627 internal(ios); 5628 { 5629 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5630 std::string ex(str, iter.base()); 5631 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 5632 assert(ios.width() == 0); 5633 } 5634 } 5635 ios.imbue(lg); 5636 { 5637 ios.width(0); 5638 { 5639 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5640 std::string ex(str, iter.base()); 5641 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5642 assert(ios.width() == 0); 5643 } 5644 ios.width(25); 5645 left(ios); 5646 { 5647 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5648 std::string ex(str, iter.base()); 5649 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5650 assert(ios.width() == 0); 5651 } 5652 ios.width(25); 5653 right(ios); 5654 { 5655 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5656 std::string ex(str, iter.base()); 5657 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5658 assert(ios.width() == 0); 5659 } 5660 ios.width(25); 5661 internal(ios); 5662 { 5663 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5664 std::string ex(str, iter.base()); 5665 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5666 assert(ios.width() == 0); 5667 } 5668 } 5669 } 5670 } 5671 } 5672 uppercase(ios); 5673 { 5674 noshowpos(ios); 5675 { 5676 noshowpoint(ios); 5677 { 5678 ios.imbue(lc); 5679 { 5680 ios.width(0); 5681 { 5682 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5683 std::string ex(str, iter.base()); 5684 assert(ex == "1234567890.125"); 5685 assert(ios.width() == 0); 5686 } 5687 ios.width(25); 5688 left(ios); 5689 { 5690 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5691 std::string ex(str, iter.base()); 5692 assert(ex == "1234567890.125***********"); 5693 assert(ios.width() == 0); 5694 } 5695 ios.width(25); 5696 right(ios); 5697 { 5698 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5699 std::string ex(str, iter.base()); 5700 assert(ex == "***********1234567890.125"); 5701 assert(ios.width() == 0); 5702 } 5703 ios.width(25); 5704 internal(ios); 5705 { 5706 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5707 std::string ex(str, iter.base()); 5708 assert(ex == "***********1234567890.125"); 5709 assert(ios.width() == 0); 5710 } 5711 } 5712 ios.imbue(lg); 5713 { 5714 ios.width(0); 5715 { 5716 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5717 std::string ex(str, iter.base()); 5718 assert(ex == "1_234_567_89_0;125"); 5719 assert(ios.width() == 0); 5720 } 5721 ios.width(25); 5722 left(ios); 5723 { 5724 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5725 std::string ex(str, iter.base()); 5726 assert(ex == "1_234_567_89_0;125*******"); 5727 assert(ios.width() == 0); 5728 } 5729 ios.width(25); 5730 right(ios); 5731 { 5732 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5733 std::string ex(str, iter.base()); 5734 assert(ex == "*******1_234_567_89_0;125"); 5735 assert(ios.width() == 0); 5736 } 5737 ios.width(25); 5738 internal(ios); 5739 { 5740 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5741 std::string ex(str, iter.base()); 5742 assert(ex == "*******1_234_567_89_0;125"); 5743 assert(ios.width() == 0); 5744 } 5745 } 5746 } 5747 showpoint(ios); 5748 { 5749 ios.imbue(lc); 5750 { 5751 ios.width(0); 5752 { 5753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5754 std::string ex(str, iter.base()); 5755 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 5756 assert(ios.width() == 0); 5757 } 5758 ios.width(25); 5759 left(ios); 5760 { 5761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5762 std::string ex(str, iter.base()); 5763 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 5764 assert(ios.width() == 0); 5765 } 5766 ios.width(25); 5767 right(ios); 5768 { 5769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5770 std::string ex(str, iter.base()); 5771 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 5772 assert(ios.width() == 0); 5773 } 5774 ios.width(25); 5775 internal(ios); 5776 { 5777 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5778 std::string ex(str, iter.base()); 5779 assert(ex == "1234567890.12500000000000000000000000000000000000000000000000"); 5780 assert(ios.width() == 0); 5781 } 5782 } 5783 ios.imbue(lg); 5784 { 5785 ios.width(0); 5786 { 5787 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5788 std::string ex(str, iter.base()); 5789 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5790 assert(ios.width() == 0); 5791 } 5792 ios.width(25); 5793 left(ios); 5794 { 5795 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5796 std::string ex(str, iter.base()); 5797 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5798 assert(ios.width() == 0); 5799 } 5800 ios.width(25); 5801 right(ios); 5802 { 5803 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5804 std::string ex(str, iter.base()); 5805 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5806 assert(ios.width() == 0); 5807 } 5808 ios.width(25); 5809 internal(ios); 5810 { 5811 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5812 std::string ex(str, iter.base()); 5813 assert(ex == "1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5814 assert(ios.width() == 0); 5815 } 5816 } 5817 } 5818 } 5819 showpos(ios); 5820 { 5821 noshowpoint(ios); 5822 { 5823 ios.imbue(lc); 5824 { 5825 ios.width(0); 5826 { 5827 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5828 std::string ex(str, iter.base()); 5829 assert(ex == "+1234567890.125"); 5830 assert(ios.width() == 0); 5831 } 5832 ios.width(25); 5833 left(ios); 5834 { 5835 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5836 std::string ex(str, iter.base()); 5837 assert(ex == "+1234567890.125**********"); 5838 assert(ios.width() == 0); 5839 } 5840 ios.width(25); 5841 right(ios); 5842 { 5843 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5844 std::string ex(str, iter.base()); 5845 assert(ex == "**********+1234567890.125"); 5846 assert(ios.width() == 0); 5847 } 5848 ios.width(25); 5849 internal(ios); 5850 { 5851 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5852 std::string ex(str, iter.base()); 5853 assert(ex == "+**********1234567890.125"); 5854 assert(ios.width() == 0); 5855 } 5856 } 5857 ios.imbue(lg); 5858 { 5859 ios.width(0); 5860 { 5861 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5862 std::string ex(str, iter.base()); 5863 assert(ex == "+1_234_567_89_0;125"); 5864 assert(ios.width() == 0); 5865 } 5866 ios.width(25); 5867 left(ios); 5868 { 5869 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5870 std::string ex(str, iter.base()); 5871 assert(ex == "+1_234_567_89_0;125******"); 5872 assert(ios.width() == 0); 5873 } 5874 ios.width(25); 5875 right(ios); 5876 { 5877 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5878 std::string ex(str, iter.base()); 5879 assert(ex == "******+1_234_567_89_0;125"); 5880 assert(ios.width() == 0); 5881 } 5882 ios.width(25); 5883 internal(ios); 5884 { 5885 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5886 std::string ex(str, iter.base()); 5887 assert(ex == "+******1_234_567_89_0;125"); 5888 assert(ios.width() == 0); 5889 } 5890 } 5891 } 5892 showpoint(ios); 5893 { 5894 ios.imbue(lc); 5895 { 5896 ios.width(0); 5897 { 5898 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5899 std::string ex(str, iter.base()); 5900 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 5901 assert(ios.width() == 0); 5902 } 5903 ios.width(25); 5904 left(ios); 5905 { 5906 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5907 std::string ex(str, iter.base()); 5908 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 5909 assert(ios.width() == 0); 5910 } 5911 ios.width(25); 5912 right(ios); 5913 { 5914 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5915 std::string ex(str, iter.base()); 5916 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 5917 assert(ios.width() == 0); 5918 } 5919 ios.width(25); 5920 internal(ios); 5921 { 5922 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5923 std::string ex(str, iter.base()); 5924 assert(ex == "+1234567890.12500000000000000000000000000000000000000000000000"); 5925 assert(ios.width() == 0); 5926 } 5927 } 5928 ios.imbue(lg); 5929 { 5930 ios.width(0); 5931 { 5932 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5933 std::string ex(str, iter.base()); 5934 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5935 assert(ios.width() == 0); 5936 } 5937 ios.width(25); 5938 left(ios); 5939 { 5940 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5941 std::string ex(str, iter.base()); 5942 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5943 assert(ios.width() == 0); 5944 } 5945 ios.width(25); 5946 right(ios); 5947 { 5948 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5949 std::string ex(str, iter.base()); 5950 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5951 assert(ios.width() == 0); 5952 } 5953 ios.width(25); 5954 internal(ios); 5955 { 5956 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5957 std::string ex(str, iter.base()); 5958 assert(ex == "+1_234_567_89_0;12500000000000000000000000000000000000000000000000"); 5959 assert(ios.width() == 0); 5960 } 5961 } 5962 } 5963 } 5964 } 5965 } 5966 } 5967 } 5968 } 5969 5970 void test3() 5971 { 5972 char str[200]; 5973 output_iterator<char*> iter; 5974 std::locale lc = std::locale::classic(); 5975 std::locale lg(lc, new my_numpunct); 5976 const my_facet f(1); 5977 { 5978 double v = +0.; 5979 std::ios ios(0); 5980 fixed(ios); 5981 // %f 5982 { 5983 ios.precision(0); 5984 { 5985 nouppercase(ios); 5986 { 5987 noshowpos(ios); 5988 { 5989 noshowpoint(ios); 5990 { 5991 ios.imbue(lc); 5992 { 5993 ios.width(0); 5994 { 5995 iter = f.put(output_iterator<char*>(str), ios, '*', v); 5996 std::string ex(str, iter.base()); 5997 assert(ex == "0"); 5998 assert(ios.width() == 0); 5999 } 6000 ios.width(25); 6001 left(ios); 6002 { 6003 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6004 std::string ex(str, iter.base()); 6005 assert(ex == "0************************"); 6006 assert(ios.width() == 0); 6007 } 6008 ios.width(25); 6009 right(ios); 6010 { 6011 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6012 std::string ex(str, iter.base()); 6013 assert(ex == "************************0"); 6014 assert(ios.width() == 0); 6015 } 6016 ios.width(25); 6017 internal(ios); 6018 { 6019 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6020 std::string ex(str, iter.base()); 6021 assert(ex == "************************0"); 6022 assert(ios.width() == 0); 6023 } 6024 } 6025 ios.imbue(lg); 6026 { 6027 ios.width(0); 6028 { 6029 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6030 std::string ex(str, iter.base()); 6031 assert(ex == "0"); 6032 assert(ios.width() == 0); 6033 } 6034 ios.width(25); 6035 left(ios); 6036 { 6037 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6038 std::string ex(str, iter.base()); 6039 assert(ex == "0************************"); 6040 assert(ios.width() == 0); 6041 } 6042 ios.width(25); 6043 right(ios); 6044 { 6045 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6046 std::string ex(str, iter.base()); 6047 assert(ex == "************************0"); 6048 assert(ios.width() == 0); 6049 } 6050 ios.width(25); 6051 internal(ios); 6052 { 6053 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6054 std::string ex(str, iter.base()); 6055 assert(ex == "************************0"); 6056 assert(ios.width() == 0); 6057 } 6058 } 6059 } 6060 showpoint(ios); 6061 { 6062 ios.imbue(lc); 6063 { 6064 ios.width(0); 6065 { 6066 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6067 std::string ex(str, iter.base()); 6068 assert(ex == "0."); 6069 assert(ios.width() == 0); 6070 } 6071 ios.width(25); 6072 left(ios); 6073 { 6074 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6075 std::string ex(str, iter.base()); 6076 assert(ex == "0.***********************"); 6077 assert(ios.width() == 0); 6078 } 6079 ios.width(25); 6080 right(ios); 6081 { 6082 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6083 std::string ex(str, iter.base()); 6084 assert(ex == "***********************0."); 6085 assert(ios.width() == 0); 6086 } 6087 ios.width(25); 6088 internal(ios); 6089 { 6090 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6091 std::string ex(str, iter.base()); 6092 assert(ex == "***********************0."); 6093 assert(ios.width() == 0); 6094 } 6095 } 6096 ios.imbue(lg); 6097 { 6098 ios.width(0); 6099 { 6100 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6101 std::string ex(str, iter.base()); 6102 assert(ex == "0;"); 6103 assert(ios.width() == 0); 6104 } 6105 ios.width(25); 6106 left(ios); 6107 { 6108 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6109 std::string ex(str, iter.base()); 6110 assert(ex == "0;***********************"); 6111 assert(ios.width() == 0); 6112 } 6113 ios.width(25); 6114 right(ios); 6115 { 6116 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6117 std::string ex(str, iter.base()); 6118 assert(ex == "***********************0;"); 6119 assert(ios.width() == 0); 6120 } 6121 ios.width(25); 6122 internal(ios); 6123 { 6124 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6125 std::string ex(str, iter.base()); 6126 assert(ex == "***********************0;"); 6127 assert(ios.width() == 0); 6128 } 6129 } 6130 } 6131 } 6132 showpos(ios); 6133 { 6134 noshowpoint(ios); 6135 { 6136 ios.imbue(lc); 6137 { 6138 ios.width(0); 6139 { 6140 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6141 std::string ex(str, iter.base()); 6142 assert(ex == "+0"); 6143 assert(ios.width() == 0); 6144 } 6145 ios.width(25); 6146 left(ios); 6147 { 6148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6149 std::string ex(str, iter.base()); 6150 assert(ex == "+0***********************"); 6151 assert(ios.width() == 0); 6152 } 6153 ios.width(25); 6154 right(ios); 6155 { 6156 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6157 std::string ex(str, iter.base()); 6158 assert(ex == "***********************+0"); 6159 assert(ios.width() == 0); 6160 } 6161 ios.width(25); 6162 internal(ios); 6163 { 6164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6165 std::string ex(str, iter.base()); 6166 assert(ex == "+***********************0"); 6167 assert(ios.width() == 0); 6168 } 6169 } 6170 ios.imbue(lg); 6171 { 6172 ios.width(0); 6173 { 6174 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6175 std::string ex(str, iter.base()); 6176 assert(ex == "+0"); 6177 assert(ios.width() == 0); 6178 } 6179 ios.width(25); 6180 left(ios); 6181 { 6182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6183 std::string ex(str, iter.base()); 6184 assert(ex == "+0***********************"); 6185 assert(ios.width() == 0); 6186 } 6187 ios.width(25); 6188 right(ios); 6189 { 6190 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6191 std::string ex(str, iter.base()); 6192 assert(ex == "***********************+0"); 6193 assert(ios.width() == 0); 6194 } 6195 ios.width(25); 6196 internal(ios); 6197 { 6198 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6199 std::string ex(str, iter.base()); 6200 assert(ex == "+***********************0"); 6201 assert(ios.width() == 0); 6202 } 6203 } 6204 } 6205 showpoint(ios); 6206 { 6207 ios.imbue(lc); 6208 { 6209 ios.width(0); 6210 { 6211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6212 std::string ex(str, iter.base()); 6213 assert(ex == "+0."); 6214 assert(ios.width() == 0); 6215 } 6216 ios.width(25); 6217 left(ios); 6218 { 6219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6220 std::string ex(str, iter.base()); 6221 assert(ex == "+0.**********************"); 6222 assert(ios.width() == 0); 6223 } 6224 ios.width(25); 6225 right(ios); 6226 { 6227 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6228 std::string ex(str, iter.base()); 6229 assert(ex == "**********************+0."); 6230 assert(ios.width() == 0); 6231 } 6232 ios.width(25); 6233 internal(ios); 6234 { 6235 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6236 std::string ex(str, iter.base()); 6237 assert(ex == "+**********************0."); 6238 assert(ios.width() == 0); 6239 } 6240 } 6241 ios.imbue(lg); 6242 { 6243 ios.width(0); 6244 { 6245 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6246 std::string ex(str, iter.base()); 6247 assert(ex == "+0;"); 6248 assert(ios.width() == 0); 6249 } 6250 ios.width(25); 6251 left(ios); 6252 { 6253 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6254 std::string ex(str, iter.base()); 6255 assert(ex == "+0;**********************"); 6256 assert(ios.width() == 0); 6257 } 6258 ios.width(25); 6259 right(ios); 6260 { 6261 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6262 std::string ex(str, iter.base()); 6263 assert(ex == "**********************+0;"); 6264 assert(ios.width() == 0); 6265 } 6266 ios.width(25); 6267 internal(ios); 6268 { 6269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6270 std::string ex(str, iter.base()); 6271 assert(ex == "+**********************0;"); 6272 assert(ios.width() == 0); 6273 } 6274 } 6275 } 6276 } 6277 } 6278 uppercase(ios); 6279 { 6280 noshowpos(ios); 6281 { 6282 noshowpoint(ios); 6283 { 6284 ios.imbue(lc); 6285 { 6286 ios.width(0); 6287 { 6288 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6289 std::string ex(str, iter.base()); 6290 assert(ex == "0"); 6291 assert(ios.width() == 0); 6292 } 6293 ios.width(25); 6294 left(ios); 6295 { 6296 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6297 std::string ex(str, iter.base()); 6298 assert(ex == "0************************"); 6299 assert(ios.width() == 0); 6300 } 6301 ios.width(25); 6302 right(ios); 6303 { 6304 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6305 std::string ex(str, iter.base()); 6306 assert(ex == "************************0"); 6307 assert(ios.width() == 0); 6308 } 6309 ios.width(25); 6310 internal(ios); 6311 { 6312 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6313 std::string ex(str, iter.base()); 6314 assert(ex == "************************0"); 6315 assert(ios.width() == 0); 6316 } 6317 } 6318 ios.imbue(lg); 6319 { 6320 ios.width(0); 6321 { 6322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6323 std::string ex(str, iter.base()); 6324 assert(ex == "0"); 6325 assert(ios.width() == 0); 6326 } 6327 ios.width(25); 6328 left(ios); 6329 { 6330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6331 std::string ex(str, iter.base()); 6332 assert(ex == "0************************"); 6333 assert(ios.width() == 0); 6334 } 6335 ios.width(25); 6336 right(ios); 6337 { 6338 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6339 std::string ex(str, iter.base()); 6340 assert(ex == "************************0"); 6341 assert(ios.width() == 0); 6342 } 6343 ios.width(25); 6344 internal(ios); 6345 { 6346 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6347 std::string ex(str, iter.base()); 6348 assert(ex == "************************0"); 6349 assert(ios.width() == 0); 6350 } 6351 } 6352 } 6353 showpoint(ios); 6354 { 6355 ios.imbue(lc); 6356 { 6357 ios.width(0); 6358 { 6359 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6360 std::string ex(str, iter.base()); 6361 assert(ex == "0."); 6362 assert(ios.width() == 0); 6363 } 6364 ios.width(25); 6365 left(ios); 6366 { 6367 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6368 std::string ex(str, iter.base()); 6369 assert(ex == "0.***********************"); 6370 assert(ios.width() == 0); 6371 } 6372 ios.width(25); 6373 right(ios); 6374 { 6375 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6376 std::string ex(str, iter.base()); 6377 assert(ex == "***********************0."); 6378 assert(ios.width() == 0); 6379 } 6380 ios.width(25); 6381 internal(ios); 6382 { 6383 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6384 std::string ex(str, iter.base()); 6385 assert(ex == "***********************0."); 6386 assert(ios.width() == 0); 6387 } 6388 } 6389 ios.imbue(lg); 6390 { 6391 ios.width(0); 6392 { 6393 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6394 std::string ex(str, iter.base()); 6395 assert(ex == "0;"); 6396 assert(ios.width() == 0); 6397 } 6398 ios.width(25); 6399 left(ios); 6400 { 6401 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6402 std::string ex(str, iter.base()); 6403 assert(ex == "0;***********************"); 6404 assert(ios.width() == 0); 6405 } 6406 ios.width(25); 6407 right(ios); 6408 { 6409 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6410 std::string ex(str, iter.base()); 6411 assert(ex == "***********************0;"); 6412 assert(ios.width() == 0); 6413 } 6414 ios.width(25); 6415 internal(ios); 6416 { 6417 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6418 std::string ex(str, iter.base()); 6419 assert(ex == "***********************0;"); 6420 assert(ios.width() == 0); 6421 } 6422 } 6423 } 6424 } 6425 showpos(ios); 6426 { 6427 noshowpoint(ios); 6428 { 6429 ios.imbue(lc); 6430 { 6431 ios.width(0); 6432 { 6433 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6434 std::string ex(str, iter.base()); 6435 assert(ex == "+0"); 6436 assert(ios.width() == 0); 6437 } 6438 ios.width(25); 6439 left(ios); 6440 { 6441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6442 std::string ex(str, iter.base()); 6443 assert(ex == "+0***********************"); 6444 assert(ios.width() == 0); 6445 } 6446 ios.width(25); 6447 right(ios); 6448 { 6449 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6450 std::string ex(str, iter.base()); 6451 assert(ex == "***********************+0"); 6452 assert(ios.width() == 0); 6453 } 6454 ios.width(25); 6455 internal(ios); 6456 { 6457 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6458 std::string ex(str, iter.base()); 6459 assert(ex == "+***********************0"); 6460 assert(ios.width() == 0); 6461 } 6462 } 6463 ios.imbue(lg); 6464 { 6465 ios.width(0); 6466 { 6467 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6468 std::string ex(str, iter.base()); 6469 assert(ex == "+0"); 6470 assert(ios.width() == 0); 6471 } 6472 ios.width(25); 6473 left(ios); 6474 { 6475 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6476 std::string ex(str, iter.base()); 6477 assert(ex == "+0***********************"); 6478 assert(ios.width() == 0); 6479 } 6480 ios.width(25); 6481 right(ios); 6482 { 6483 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6484 std::string ex(str, iter.base()); 6485 assert(ex == "***********************+0"); 6486 assert(ios.width() == 0); 6487 } 6488 ios.width(25); 6489 internal(ios); 6490 { 6491 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6492 std::string ex(str, iter.base()); 6493 assert(ex == "+***********************0"); 6494 assert(ios.width() == 0); 6495 } 6496 } 6497 } 6498 showpoint(ios); 6499 { 6500 ios.imbue(lc); 6501 { 6502 ios.width(0); 6503 { 6504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6505 std::string ex(str, iter.base()); 6506 assert(ex == "+0."); 6507 assert(ios.width() == 0); 6508 } 6509 ios.width(25); 6510 left(ios); 6511 { 6512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6513 std::string ex(str, iter.base()); 6514 assert(ex == "+0.**********************"); 6515 assert(ios.width() == 0); 6516 } 6517 ios.width(25); 6518 right(ios); 6519 { 6520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6521 std::string ex(str, iter.base()); 6522 assert(ex == "**********************+0."); 6523 assert(ios.width() == 0); 6524 } 6525 ios.width(25); 6526 internal(ios); 6527 { 6528 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6529 std::string ex(str, iter.base()); 6530 assert(ex == "+**********************0."); 6531 assert(ios.width() == 0); 6532 } 6533 } 6534 ios.imbue(lg); 6535 { 6536 ios.width(0); 6537 { 6538 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6539 std::string ex(str, iter.base()); 6540 assert(ex == "+0;"); 6541 assert(ios.width() == 0); 6542 } 6543 ios.width(25); 6544 left(ios); 6545 { 6546 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6547 std::string ex(str, iter.base()); 6548 assert(ex == "+0;**********************"); 6549 assert(ios.width() == 0); 6550 } 6551 ios.width(25); 6552 right(ios); 6553 { 6554 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6555 std::string ex(str, iter.base()); 6556 assert(ex == "**********************+0;"); 6557 assert(ios.width() == 0); 6558 } 6559 ios.width(25); 6560 internal(ios); 6561 { 6562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6563 std::string ex(str, iter.base()); 6564 assert(ex == "+**********************0;"); 6565 assert(ios.width() == 0); 6566 } 6567 } 6568 } 6569 } 6570 } 6571 } 6572 ios.precision(1); 6573 { 6574 nouppercase(ios); 6575 { 6576 noshowpos(ios); 6577 { 6578 noshowpoint(ios); 6579 { 6580 ios.imbue(lc); 6581 { 6582 ios.width(0); 6583 { 6584 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6585 std::string ex(str, iter.base()); 6586 assert(ex == "0.0"); 6587 assert(ios.width() == 0); 6588 } 6589 ios.width(25); 6590 left(ios); 6591 { 6592 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6593 std::string ex(str, iter.base()); 6594 assert(ex == "0.0**********************"); 6595 assert(ios.width() == 0); 6596 } 6597 ios.width(25); 6598 right(ios); 6599 { 6600 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6601 std::string ex(str, iter.base()); 6602 assert(ex == "**********************0.0"); 6603 assert(ios.width() == 0); 6604 } 6605 ios.width(25); 6606 internal(ios); 6607 { 6608 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6609 std::string ex(str, iter.base()); 6610 assert(ex == "**********************0.0"); 6611 assert(ios.width() == 0); 6612 } 6613 } 6614 ios.imbue(lg); 6615 { 6616 ios.width(0); 6617 { 6618 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6619 std::string ex(str, iter.base()); 6620 assert(ex == "0;0"); 6621 assert(ios.width() == 0); 6622 } 6623 ios.width(25); 6624 left(ios); 6625 { 6626 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6627 std::string ex(str, iter.base()); 6628 assert(ex == "0;0**********************"); 6629 assert(ios.width() == 0); 6630 } 6631 ios.width(25); 6632 right(ios); 6633 { 6634 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6635 std::string ex(str, iter.base()); 6636 assert(ex == "**********************0;0"); 6637 assert(ios.width() == 0); 6638 } 6639 ios.width(25); 6640 internal(ios); 6641 { 6642 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6643 std::string ex(str, iter.base()); 6644 assert(ex == "**********************0;0"); 6645 assert(ios.width() == 0); 6646 } 6647 } 6648 } 6649 showpoint(ios); 6650 { 6651 ios.imbue(lc); 6652 { 6653 ios.width(0); 6654 { 6655 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6656 std::string ex(str, iter.base()); 6657 assert(ex == "0.0"); 6658 assert(ios.width() == 0); 6659 } 6660 ios.width(25); 6661 left(ios); 6662 { 6663 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6664 std::string ex(str, iter.base()); 6665 assert(ex == "0.0**********************"); 6666 assert(ios.width() == 0); 6667 } 6668 ios.width(25); 6669 right(ios); 6670 { 6671 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6672 std::string ex(str, iter.base()); 6673 assert(ex == "**********************0.0"); 6674 assert(ios.width() == 0); 6675 } 6676 ios.width(25); 6677 internal(ios); 6678 { 6679 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6680 std::string ex(str, iter.base()); 6681 assert(ex == "**********************0.0"); 6682 assert(ios.width() == 0); 6683 } 6684 } 6685 ios.imbue(lg); 6686 { 6687 ios.width(0); 6688 { 6689 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6690 std::string ex(str, iter.base()); 6691 assert(ex == "0;0"); 6692 assert(ios.width() == 0); 6693 } 6694 ios.width(25); 6695 left(ios); 6696 { 6697 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6698 std::string ex(str, iter.base()); 6699 assert(ex == "0;0**********************"); 6700 assert(ios.width() == 0); 6701 } 6702 ios.width(25); 6703 right(ios); 6704 { 6705 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6706 std::string ex(str, iter.base()); 6707 assert(ex == "**********************0;0"); 6708 assert(ios.width() == 0); 6709 } 6710 ios.width(25); 6711 internal(ios); 6712 { 6713 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6714 std::string ex(str, iter.base()); 6715 assert(ex == "**********************0;0"); 6716 assert(ios.width() == 0); 6717 } 6718 } 6719 } 6720 } 6721 showpos(ios); 6722 { 6723 noshowpoint(ios); 6724 { 6725 ios.imbue(lc); 6726 { 6727 ios.width(0); 6728 { 6729 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6730 std::string ex(str, iter.base()); 6731 assert(ex == "+0.0"); 6732 assert(ios.width() == 0); 6733 } 6734 ios.width(25); 6735 left(ios); 6736 { 6737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6738 std::string ex(str, iter.base()); 6739 assert(ex == "+0.0*********************"); 6740 assert(ios.width() == 0); 6741 } 6742 ios.width(25); 6743 right(ios); 6744 { 6745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6746 std::string ex(str, iter.base()); 6747 assert(ex == "*********************+0.0"); 6748 assert(ios.width() == 0); 6749 } 6750 ios.width(25); 6751 internal(ios); 6752 { 6753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6754 std::string ex(str, iter.base()); 6755 assert(ex == "+*********************0.0"); 6756 assert(ios.width() == 0); 6757 } 6758 } 6759 ios.imbue(lg); 6760 { 6761 ios.width(0); 6762 { 6763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6764 std::string ex(str, iter.base()); 6765 assert(ex == "+0;0"); 6766 assert(ios.width() == 0); 6767 } 6768 ios.width(25); 6769 left(ios); 6770 { 6771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6772 std::string ex(str, iter.base()); 6773 assert(ex == "+0;0*********************"); 6774 assert(ios.width() == 0); 6775 } 6776 ios.width(25); 6777 right(ios); 6778 { 6779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6780 std::string ex(str, iter.base()); 6781 assert(ex == "*********************+0;0"); 6782 assert(ios.width() == 0); 6783 } 6784 ios.width(25); 6785 internal(ios); 6786 { 6787 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6788 std::string ex(str, iter.base()); 6789 assert(ex == "+*********************0;0"); 6790 assert(ios.width() == 0); 6791 } 6792 } 6793 } 6794 showpoint(ios); 6795 { 6796 ios.imbue(lc); 6797 { 6798 ios.width(0); 6799 { 6800 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6801 std::string ex(str, iter.base()); 6802 assert(ex == "+0.0"); 6803 assert(ios.width() == 0); 6804 } 6805 ios.width(25); 6806 left(ios); 6807 { 6808 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6809 std::string ex(str, iter.base()); 6810 assert(ex == "+0.0*********************"); 6811 assert(ios.width() == 0); 6812 } 6813 ios.width(25); 6814 right(ios); 6815 { 6816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6817 std::string ex(str, iter.base()); 6818 assert(ex == "*********************+0.0"); 6819 assert(ios.width() == 0); 6820 } 6821 ios.width(25); 6822 internal(ios); 6823 { 6824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6825 std::string ex(str, iter.base()); 6826 assert(ex == "+*********************0.0"); 6827 assert(ios.width() == 0); 6828 } 6829 } 6830 ios.imbue(lg); 6831 { 6832 ios.width(0); 6833 { 6834 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6835 std::string ex(str, iter.base()); 6836 assert(ex == "+0;0"); 6837 assert(ios.width() == 0); 6838 } 6839 ios.width(25); 6840 left(ios); 6841 { 6842 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6843 std::string ex(str, iter.base()); 6844 assert(ex == "+0;0*********************"); 6845 assert(ios.width() == 0); 6846 } 6847 ios.width(25); 6848 right(ios); 6849 { 6850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6851 std::string ex(str, iter.base()); 6852 assert(ex == "*********************+0;0"); 6853 assert(ios.width() == 0); 6854 } 6855 ios.width(25); 6856 internal(ios); 6857 { 6858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6859 std::string ex(str, iter.base()); 6860 assert(ex == "+*********************0;0"); 6861 assert(ios.width() == 0); 6862 } 6863 } 6864 } 6865 } 6866 } 6867 uppercase(ios); 6868 { 6869 noshowpos(ios); 6870 { 6871 noshowpoint(ios); 6872 { 6873 ios.imbue(lc); 6874 { 6875 ios.width(0); 6876 { 6877 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6878 std::string ex(str, iter.base()); 6879 assert(ex == "0.0"); 6880 assert(ios.width() == 0); 6881 } 6882 ios.width(25); 6883 left(ios); 6884 { 6885 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6886 std::string ex(str, iter.base()); 6887 assert(ex == "0.0**********************"); 6888 assert(ios.width() == 0); 6889 } 6890 ios.width(25); 6891 right(ios); 6892 { 6893 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6894 std::string ex(str, iter.base()); 6895 assert(ex == "**********************0.0"); 6896 assert(ios.width() == 0); 6897 } 6898 ios.width(25); 6899 internal(ios); 6900 { 6901 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6902 std::string ex(str, iter.base()); 6903 assert(ex == "**********************0.0"); 6904 assert(ios.width() == 0); 6905 } 6906 } 6907 ios.imbue(lg); 6908 { 6909 ios.width(0); 6910 { 6911 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6912 std::string ex(str, iter.base()); 6913 assert(ex == "0;0"); 6914 assert(ios.width() == 0); 6915 } 6916 ios.width(25); 6917 left(ios); 6918 { 6919 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6920 std::string ex(str, iter.base()); 6921 assert(ex == "0;0**********************"); 6922 assert(ios.width() == 0); 6923 } 6924 ios.width(25); 6925 right(ios); 6926 { 6927 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6928 std::string ex(str, iter.base()); 6929 assert(ex == "**********************0;0"); 6930 assert(ios.width() == 0); 6931 } 6932 ios.width(25); 6933 internal(ios); 6934 { 6935 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6936 std::string ex(str, iter.base()); 6937 assert(ex == "**********************0;0"); 6938 assert(ios.width() == 0); 6939 } 6940 } 6941 } 6942 showpoint(ios); 6943 { 6944 ios.imbue(lc); 6945 { 6946 ios.width(0); 6947 { 6948 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6949 std::string ex(str, iter.base()); 6950 assert(ex == "0.0"); 6951 assert(ios.width() == 0); 6952 } 6953 ios.width(25); 6954 left(ios); 6955 { 6956 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6957 std::string ex(str, iter.base()); 6958 assert(ex == "0.0**********************"); 6959 assert(ios.width() == 0); 6960 } 6961 ios.width(25); 6962 right(ios); 6963 { 6964 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6965 std::string ex(str, iter.base()); 6966 assert(ex == "**********************0.0"); 6967 assert(ios.width() == 0); 6968 } 6969 ios.width(25); 6970 internal(ios); 6971 { 6972 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6973 std::string ex(str, iter.base()); 6974 assert(ex == "**********************0.0"); 6975 assert(ios.width() == 0); 6976 } 6977 } 6978 ios.imbue(lg); 6979 { 6980 ios.width(0); 6981 { 6982 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6983 std::string ex(str, iter.base()); 6984 assert(ex == "0;0"); 6985 assert(ios.width() == 0); 6986 } 6987 ios.width(25); 6988 left(ios); 6989 { 6990 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6991 std::string ex(str, iter.base()); 6992 assert(ex == "0;0**********************"); 6993 assert(ios.width() == 0); 6994 } 6995 ios.width(25); 6996 right(ios); 6997 { 6998 iter = f.put(output_iterator<char*>(str), ios, '*', v); 6999 std::string ex(str, iter.base()); 7000 assert(ex == "**********************0;0"); 7001 assert(ios.width() == 0); 7002 } 7003 ios.width(25); 7004 internal(ios); 7005 { 7006 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7007 std::string ex(str, iter.base()); 7008 assert(ex == "**********************0;0"); 7009 assert(ios.width() == 0); 7010 } 7011 } 7012 } 7013 } 7014 showpos(ios); 7015 { 7016 noshowpoint(ios); 7017 { 7018 ios.imbue(lc); 7019 { 7020 ios.width(0); 7021 { 7022 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7023 std::string ex(str, iter.base()); 7024 assert(ex == "+0.0"); 7025 assert(ios.width() == 0); 7026 } 7027 ios.width(25); 7028 left(ios); 7029 { 7030 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7031 std::string ex(str, iter.base()); 7032 assert(ex == "+0.0*********************"); 7033 assert(ios.width() == 0); 7034 } 7035 ios.width(25); 7036 right(ios); 7037 { 7038 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7039 std::string ex(str, iter.base()); 7040 assert(ex == "*********************+0.0"); 7041 assert(ios.width() == 0); 7042 } 7043 ios.width(25); 7044 internal(ios); 7045 { 7046 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7047 std::string ex(str, iter.base()); 7048 assert(ex == "+*********************0.0"); 7049 assert(ios.width() == 0); 7050 } 7051 } 7052 ios.imbue(lg); 7053 { 7054 ios.width(0); 7055 { 7056 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7057 std::string ex(str, iter.base()); 7058 assert(ex == "+0;0"); 7059 assert(ios.width() == 0); 7060 } 7061 ios.width(25); 7062 left(ios); 7063 { 7064 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7065 std::string ex(str, iter.base()); 7066 assert(ex == "+0;0*********************"); 7067 assert(ios.width() == 0); 7068 } 7069 ios.width(25); 7070 right(ios); 7071 { 7072 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7073 std::string ex(str, iter.base()); 7074 assert(ex == "*********************+0;0"); 7075 assert(ios.width() == 0); 7076 } 7077 ios.width(25); 7078 internal(ios); 7079 { 7080 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7081 std::string ex(str, iter.base()); 7082 assert(ex == "+*********************0;0"); 7083 assert(ios.width() == 0); 7084 } 7085 } 7086 } 7087 showpoint(ios); 7088 { 7089 ios.imbue(lc); 7090 { 7091 ios.width(0); 7092 { 7093 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7094 std::string ex(str, iter.base()); 7095 assert(ex == "+0.0"); 7096 assert(ios.width() == 0); 7097 } 7098 ios.width(25); 7099 left(ios); 7100 { 7101 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7102 std::string ex(str, iter.base()); 7103 assert(ex == "+0.0*********************"); 7104 assert(ios.width() == 0); 7105 } 7106 ios.width(25); 7107 right(ios); 7108 { 7109 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7110 std::string ex(str, iter.base()); 7111 assert(ex == "*********************+0.0"); 7112 assert(ios.width() == 0); 7113 } 7114 ios.width(25); 7115 internal(ios); 7116 { 7117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7118 std::string ex(str, iter.base()); 7119 assert(ex == "+*********************0.0"); 7120 assert(ios.width() == 0); 7121 } 7122 } 7123 ios.imbue(lg); 7124 { 7125 ios.width(0); 7126 { 7127 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7128 std::string ex(str, iter.base()); 7129 assert(ex == "+0;0"); 7130 assert(ios.width() == 0); 7131 } 7132 ios.width(25); 7133 left(ios); 7134 { 7135 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7136 std::string ex(str, iter.base()); 7137 assert(ex == "+0;0*********************"); 7138 assert(ios.width() == 0); 7139 } 7140 ios.width(25); 7141 right(ios); 7142 { 7143 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7144 std::string ex(str, iter.base()); 7145 assert(ex == "*********************+0;0"); 7146 assert(ios.width() == 0); 7147 } 7148 ios.width(25); 7149 internal(ios); 7150 { 7151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7152 std::string ex(str, iter.base()); 7153 assert(ex == "+*********************0;0"); 7154 assert(ios.width() == 0); 7155 } 7156 } 7157 } 7158 } 7159 } 7160 } 7161 ios.precision(6); 7162 { 7163 nouppercase(ios); 7164 { 7165 noshowpos(ios); 7166 { 7167 noshowpoint(ios); 7168 { 7169 ios.imbue(lc); 7170 { 7171 ios.width(0); 7172 { 7173 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7174 std::string ex(str, iter.base()); 7175 assert(ex == "0.000000"); 7176 assert(ios.width() == 0); 7177 } 7178 ios.width(25); 7179 left(ios); 7180 { 7181 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7182 std::string ex(str, iter.base()); 7183 assert(ex == "0.000000*****************"); 7184 assert(ios.width() == 0); 7185 } 7186 ios.width(25); 7187 right(ios); 7188 { 7189 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7190 std::string ex(str, iter.base()); 7191 assert(ex == "*****************0.000000"); 7192 assert(ios.width() == 0); 7193 } 7194 ios.width(25); 7195 internal(ios); 7196 { 7197 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7198 std::string ex(str, iter.base()); 7199 assert(ex == "*****************0.000000"); 7200 assert(ios.width() == 0); 7201 } 7202 } 7203 ios.imbue(lg); 7204 { 7205 ios.width(0); 7206 { 7207 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7208 std::string ex(str, iter.base()); 7209 assert(ex == "0;000000"); 7210 assert(ios.width() == 0); 7211 } 7212 ios.width(25); 7213 left(ios); 7214 { 7215 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7216 std::string ex(str, iter.base()); 7217 assert(ex == "0;000000*****************"); 7218 assert(ios.width() == 0); 7219 } 7220 ios.width(25); 7221 right(ios); 7222 { 7223 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7224 std::string ex(str, iter.base()); 7225 assert(ex == "*****************0;000000"); 7226 assert(ios.width() == 0); 7227 } 7228 ios.width(25); 7229 internal(ios); 7230 { 7231 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7232 std::string ex(str, iter.base()); 7233 assert(ex == "*****************0;000000"); 7234 assert(ios.width() == 0); 7235 } 7236 } 7237 } 7238 showpoint(ios); 7239 { 7240 ios.imbue(lc); 7241 { 7242 ios.width(0); 7243 { 7244 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7245 std::string ex(str, iter.base()); 7246 assert(ex == "0.000000"); 7247 assert(ios.width() == 0); 7248 } 7249 ios.width(25); 7250 left(ios); 7251 { 7252 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7253 std::string ex(str, iter.base()); 7254 assert(ex == "0.000000*****************"); 7255 assert(ios.width() == 0); 7256 } 7257 ios.width(25); 7258 right(ios); 7259 { 7260 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7261 std::string ex(str, iter.base()); 7262 assert(ex == "*****************0.000000"); 7263 assert(ios.width() == 0); 7264 } 7265 ios.width(25); 7266 internal(ios); 7267 { 7268 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7269 std::string ex(str, iter.base()); 7270 assert(ex == "*****************0.000000"); 7271 assert(ios.width() == 0); 7272 } 7273 } 7274 ios.imbue(lg); 7275 { 7276 ios.width(0); 7277 { 7278 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7279 std::string ex(str, iter.base()); 7280 assert(ex == "0;000000"); 7281 assert(ios.width() == 0); 7282 } 7283 ios.width(25); 7284 left(ios); 7285 { 7286 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7287 std::string ex(str, iter.base()); 7288 assert(ex == "0;000000*****************"); 7289 assert(ios.width() == 0); 7290 } 7291 ios.width(25); 7292 right(ios); 7293 { 7294 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7295 std::string ex(str, iter.base()); 7296 assert(ex == "*****************0;000000"); 7297 assert(ios.width() == 0); 7298 } 7299 ios.width(25); 7300 internal(ios); 7301 { 7302 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7303 std::string ex(str, iter.base()); 7304 assert(ex == "*****************0;000000"); 7305 assert(ios.width() == 0); 7306 } 7307 } 7308 } 7309 } 7310 showpos(ios); 7311 { 7312 noshowpoint(ios); 7313 { 7314 ios.imbue(lc); 7315 { 7316 ios.width(0); 7317 { 7318 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7319 std::string ex(str, iter.base()); 7320 assert(ex == "+0.000000"); 7321 assert(ios.width() == 0); 7322 } 7323 ios.width(25); 7324 left(ios); 7325 { 7326 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7327 std::string ex(str, iter.base()); 7328 assert(ex == "+0.000000****************"); 7329 assert(ios.width() == 0); 7330 } 7331 ios.width(25); 7332 right(ios); 7333 { 7334 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7335 std::string ex(str, iter.base()); 7336 assert(ex == "****************+0.000000"); 7337 assert(ios.width() == 0); 7338 } 7339 ios.width(25); 7340 internal(ios); 7341 { 7342 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7343 std::string ex(str, iter.base()); 7344 assert(ex == "+****************0.000000"); 7345 assert(ios.width() == 0); 7346 } 7347 } 7348 ios.imbue(lg); 7349 { 7350 ios.width(0); 7351 { 7352 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7353 std::string ex(str, iter.base()); 7354 assert(ex == "+0;000000"); 7355 assert(ios.width() == 0); 7356 } 7357 ios.width(25); 7358 left(ios); 7359 { 7360 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7361 std::string ex(str, iter.base()); 7362 assert(ex == "+0;000000****************"); 7363 assert(ios.width() == 0); 7364 } 7365 ios.width(25); 7366 right(ios); 7367 { 7368 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7369 std::string ex(str, iter.base()); 7370 assert(ex == "****************+0;000000"); 7371 assert(ios.width() == 0); 7372 } 7373 ios.width(25); 7374 internal(ios); 7375 { 7376 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7377 std::string ex(str, iter.base()); 7378 assert(ex == "+****************0;000000"); 7379 assert(ios.width() == 0); 7380 } 7381 } 7382 } 7383 showpoint(ios); 7384 { 7385 ios.imbue(lc); 7386 { 7387 ios.width(0); 7388 { 7389 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7390 std::string ex(str, iter.base()); 7391 assert(ex == "+0.000000"); 7392 assert(ios.width() == 0); 7393 } 7394 ios.width(25); 7395 left(ios); 7396 { 7397 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7398 std::string ex(str, iter.base()); 7399 assert(ex == "+0.000000****************"); 7400 assert(ios.width() == 0); 7401 } 7402 ios.width(25); 7403 right(ios); 7404 { 7405 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7406 std::string ex(str, iter.base()); 7407 assert(ex == "****************+0.000000"); 7408 assert(ios.width() == 0); 7409 } 7410 ios.width(25); 7411 internal(ios); 7412 { 7413 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7414 std::string ex(str, iter.base()); 7415 assert(ex == "+****************0.000000"); 7416 assert(ios.width() == 0); 7417 } 7418 } 7419 ios.imbue(lg); 7420 { 7421 ios.width(0); 7422 { 7423 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7424 std::string ex(str, iter.base()); 7425 assert(ex == "+0;000000"); 7426 assert(ios.width() == 0); 7427 } 7428 ios.width(25); 7429 left(ios); 7430 { 7431 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7432 std::string ex(str, iter.base()); 7433 assert(ex == "+0;000000****************"); 7434 assert(ios.width() == 0); 7435 } 7436 ios.width(25); 7437 right(ios); 7438 { 7439 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7440 std::string ex(str, iter.base()); 7441 assert(ex == "****************+0;000000"); 7442 assert(ios.width() == 0); 7443 } 7444 ios.width(25); 7445 internal(ios); 7446 { 7447 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7448 std::string ex(str, iter.base()); 7449 assert(ex == "+****************0;000000"); 7450 assert(ios.width() == 0); 7451 } 7452 } 7453 } 7454 } 7455 } 7456 uppercase(ios); 7457 { 7458 noshowpos(ios); 7459 { 7460 noshowpoint(ios); 7461 { 7462 ios.imbue(lc); 7463 { 7464 ios.width(0); 7465 { 7466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7467 std::string ex(str, iter.base()); 7468 assert(ex == "0.000000"); 7469 assert(ios.width() == 0); 7470 } 7471 ios.width(25); 7472 left(ios); 7473 { 7474 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7475 std::string ex(str, iter.base()); 7476 assert(ex == "0.000000*****************"); 7477 assert(ios.width() == 0); 7478 } 7479 ios.width(25); 7480 right(ios); 7481 { 7482 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7483 std::string ex(str, iter.base()); 7484 assert(ex == "*****************0.000000"); 7485 assert(ios.width() == 0); 7486 } 7487 ios.width(25); 7488 internal(ios); 7489 { 7490 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7491 std::string ex(str, iter.base()); 7492 assert(ex == "*****************0.000000"); 7493 assert(ios.width() == 0); 7494 } 7495 } 7496 ios.imbue(lg); 7497 { 7498 ios.width(0); 7499 { 7500 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7501 std::string ex(str, iter.base()); 7502 assert(ex == "0;000000"); 7503 assert(ios.width() == 0); 7504 } 7505 ios.width(25); 7506 left(ios); 7507 { 7508 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7509 std::string ex(str, iter.base()); 7510 assert(ex == "0;000000*****************"); 7511 assert(ios.width() == 0); 7512 } 7513 ios.width(25); 7514 right(ios); 7515 { 7516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7517 std::string ex(str, iter.base()); 7518 assert(ex == "*****************0;000000"); 7519 assert(ios.width() == 0); 7520 } 7521 ios.width(25); 7522 internal(ios); 7523 { 7524 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7525 std::string ex(str, iter.base()); 7526 assert(ex == "*****************0;000000"); 7527 assert(ios.width() == 0); 7528 } 7529 } 7530 } 7531 showpoint(ios); 7532 { 7533 ios.imbue(lc); 7534 { 7535 ios.width(0); 7536 { 7537 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7538 std::string ex(str, iter.base()); 7539 assert(ex == "0.000000"); 7540 assert(ios.width() == 0); 7541 } 7542 ios.width(25); 7543 left(ios); 7544 { 7545 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7546 std::string ex(str, iter.base()); 7547 assert(ex == "0.000000*****************"); 7548 assert(ios.width() == 0); 7549 } 7550 ios.width(25); 7551 right(ios); 7552 { 7553 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7554 std::string ex(str, iter.base()); 7555 assert(ex == "*****************0.000000"); 7556 assert(ios.width() == 0); 7557 } 7558 ios.width(25); 7559 internal(ios); 7560 { 7561 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7562 std::string ex(str, iter.base()); 7563 assert(ex == "*****************0.000000"); 7564 assert(ios.width() == 0); 7565 } 7566 } 7567 ios.imbue(lg); 7568 { 7569 ios.width(0); 7570 { 7571 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7572 std::string ex(str, iter.base()); 7573 assert(ex == "0;000000"); 7574 assert(ios.width() == 0); 7575 } 7576 ios.width(25); 7577 left(ios); 7578 { 7579 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7580 std::string ex(str, iter.base()); 7581 assert(ex == "0;000000*****************"); 7582 assert(ios.width() == 0); 7583 } 7584 ios.width(25); 7585 right(ios); 7586 { 7587 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7588 std::string ex(str, iter.base()); 7589 assert(ex == "*****************0;000000"); 7590 assert(ios.width() == 0); 7591 } 7592 ios.width(25); 7593 internal(ios); 7594 { 7595 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7596 std::string ex(str, iter.base()); 7597 assert(ex == "*****************0;000000"); 7598 assert(ios.width() == 0); 7599 } 7600 } 7601 } 7602 } 7603 showpos(ios); 7604 { 7605 noshowpoint(ios); 7606 { 7607 ios.imbue(lc); 7608 { 7609 ios.width(0); 7610 { 7611 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7612 std::string ex(str, iter.base()); 7613 assert(ex == "+0.000000"); 7614 assert(ios.width() == 0); 7615 } 7616 ios.width(25); 7617 left(ios); 7618 { 7619 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7620 std::string ex(str, iter.base()); 7621 assert(ex == "+0.000000****************"); 7622 assert(ios.width() == 0); 7623 } 7624 ios.width(25); 7625 right(ios); 7626 { 7627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7628 std::string ex(str, iter.base()); 7629 assert(ex == "****************+0.000000"); 7630 assert(ios.width() == 0); 7631 } 7632 ios.width(25); 7633 internal(ios); 7634 { 7635 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7636 std::string ex(str, iter.base()); 7637 assert(ex == "+****************0.000000"); 7638 assert(ios.width() == 0); 7639 } 7640 } 7641 ios.imbue(lg); 7642 { 7643 ios.width(0); 7644 { 7645 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7646 std::string ex(str, iter.base()); 7647 assert(ex == "+0;000000"); 7648 assert(ios.width() == 0); 7649 } 7650 ios.width(25); 7651 left(ios); 7652 { 7653 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7654 std::string ex(str, iter.base()); 7655 assert(ex == "+0;000000****************"); 7656 assert(ios.width() == 0); 7657 } 7658 ios.width(25); 7659 right(ios); 7660 { 7661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7662 std::string ex(str, iter.base()); 7663 assert(ex == "****************+0;000000"); 7664 assert(ios.width() == 0); 7665 } 7666 ios.width(25); 7667 internal(ios); 7668 { 7669 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7670 std::string ex(str, iter.base()); 7671 assert(ex == "+****************0;000000"); 7672 assert(ios.width() == 0); 7673 } 7674 } 7675 } 7676 showpoint(ios); 7677 { 7678 ios.imbue(lc); 7679 { 7680 ios.width(0); 7681 { 7682 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7683 std::string ex(str, iter.base()); 7684 assert(ex == "+0.000000"); 7685 assert(ios.width() == 0); 7686 } 7687 ios.width(25); 7688 left(ios); 7689 { 7690 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7691 std::string ex(str, iter.base()); 7692 assert(ex == "+0.000000****************"); 7693 assert(ios.width() == 0); 7694 } 7695 ios.width(25); 7696 right(ios); 7697 { 7698 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7699 std::string ex(str, iter.base()); 7700 assert(ex == "****************+0.000000"); 7701 assert(ios.width() == 0); 7702 } 7703 ios.width(25); 7704 internal(ios); 7705 { 7706 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7707 std::string ex(str, iter.base()); 7708 assert(ex == "+****************0.000000"); 7709 assert(ios.width() == 0); 7710 } 7711 } 7712 ios.imbue(lg); 7713 { 7714 ios.width(0); 7715 { 7716 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7717 std::string ex(str, iter.base()); 7718 assert(ex == "+0;000000"); 7719 assert(ios.width() == 0); 7720 } 7721 ios.width(25); 7722 left(ios); 7723 { 7724 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7725 std::string ex(str, iter.base()); 7726 assert(ex == "+0;000000****************"); 7727 assert(ios.width() == 0); 7728 } 7729 ios.width(25); 7730 right(ios); 7731 { 7732 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7733 std::string ex(str, iter.base()); 7734 assert(ex == "****************+0;000000"); 7735 assert(ios.width() == 0); 7736 } 7737 ios.width(25); 7738 internal(ios); 7739 { 7740 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7741 std::string ex(str, iter.base()); 7742 assert(ex == "+****************0;000000"); 7743 assert(ios.width() == 0); 7744 } 7745 } 7746 } 7747 } 7748 } 7749 } 7750 ios.precision(16); 7751 { 7752 nouppercase(ios); 7753 { 7754 noshowpos(ios); 7755 { 7756 noshowpoint(ios); 7757 { 7758 ios.imbue(lc); 7759 { 7760 ios.width(0); 7761 { 7762 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7763 std::string ex(str, iter.base()); 7764 assert(ex == "0.0000000000000000"); 7765 assert(ios.width() == 0); 7766 } 7767 ios.width(25); 7768 left(ios); 7769 { 7770 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7771 std::string ex(str, iter.base()); 7772 assert(ex == "0.0000000000000000*******"); 7773 assert(ios.width() == 0); 7774 } 7775 ios.width(25); 7776 right(ios); 7777 { 7778 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7779 std::string ex(str, iter.base()); 7780 assert(ex == "*******0.0000000000000000"); 7781 assert(ios.width() == 0); 7782 } 7783 ios.width(25); 7784 internal(ios); 7785 { 7786 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7787 std::string ex(str, iter.base()); 7788 assert(ex == "*******0.0000000000000000"); 7789 assert(ios.width() == 0); 7790 } 7791 } 7792 ios.imbue(lg); 7793 { 7794 ios.width(0); 7795 { 7796 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7797 std::string ex(str, iter.base()); 7798 assert(ex == "0;0000000000000000"); 7799 assert(ios.width() == 0); 7800 } 7801 ios.width(25); 7802 left(ios); 7803 { 7804 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7805 std::string ex(str, iter.base()); 7806 assert(ex == "0;0000000000000000*******"); 7807 assert(ios.width() == 0); 7808 } 7809 ios.width(25); 7810 right(ios); 7811 { 7812 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7813 std::string ex(str, iter.base()); 7814 assert(ex == "*******0;0000000000000000"); 7815 assert(ios.width() == 0); 7816 } 7817 ios.width(25); 7818 internal(ios); 7819 { 7820 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7821 std::string ex(str, iter.base()); 7822 assert(ex == "*******0;0000000000000000"); 7823 assert(ios.width() == 0); 7824 } 7825 } 7826 } 7827 showpoint(ios); 7828 { 7829 ios.imbue(lc); 7830 { 7831 ios.width(0); 7832 { 7833 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7834 std::string ex(str, iter.base()); 7835 assert(ex == "0.0000000000000000"); 7836 assert(ios.width() == 0); 7837 } 7838 ios.width(25); 7839 left(ios); 7840 { 7841 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7842 std::string ex(str, iter.base()); 7843 assert(ex == "0.0000000000000000*******"); 7844 assert(ios.width() == 0); 7845 } 7846 ios.width(25); 7847 right(ios); 7848 { 7849 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7850 std::string ex(str, iter.base()); 7851 assert(ex == "*******0.0000000000000000"); 7852 assert(ios.width() == 0); 7853 } 7854 ios.width(25); 7855 internal(ios); 7856 { 7857 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7858 std::string ex(str, iter.base()); 7859 assert(ex == "*******0.0000000000000000"); 7860 assert(ios.width() == 0); 7861 } 7862 } 7863 ios.imbue(lg); 7864 { 7865 ios.width(0); 7866 { 7867 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7868 std::string ex(str, iter.base()); 7869 assert(ex == "0;0000000000000000"); 7870 assert(ios.width() == 0); 7871 } 7872 ios.width(25); 7873 left(ios); 7874 { 7875 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7876 std::string ex(str, iter.base()); 7877 assert(ex == "0;0000000000000000*******"); 7878 assert(ios.width() == 0); 7879 } 7880 ios.width(25); 7881 right(ios); 7882 { 7883 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7884 std::string ex(str, iter.base()); 7885 assert(ex == "*******0;0000000000000000"); 7886 assert(ios.width() == 0); 7887 } 7888 ios.width(25); 7889 internal(ios); 7890 { 7891 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7892 std::string ex(str, iter.base()); 7893 assert(ex == "*******0;0000000000000000"); 7894 assert(ios.width() == 0); 7895 } 7896 } 7897 } 7898 } 7899 showpos(ios); 7900 { 7901 noshowpoint(ios); 7902 { 7903 ios.imbue(lc); 7904 { 7905 ios.width(0); 7906 { 7907 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7908 std::string ex(str, iter.base()); 7909 assert(ex == "+0.0000000000000000"); 7910 assert(ios.width() == 0); 7911 } 7912 ios.width(25); 7913 left(ios); 7914 { 7915 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7916 std::string ex(str, iter.base()); 7917 assert(ex == "+0.0000000000000000******"); 7918 assert(ios.width() == 0); 7919 } 7920 ios.width(25); 7921 right(ios); 7922 { 7923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7924 std::string ex(str, iter.base()); 7925 assert(ex == "******+0.0000000000000000"); 7926 assert(ios.width() == 0); 7927 } 7928 ios.width(25); 7929 internal(ios); 7930 { 7931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7932 std::string ex(str, iter.base()); 7933 assert(ex == "+******0.0000000000000000"); 7934 assert(ios.width() == 0); 7935 } 7936 } 7937 ios.imbue(lg); 7938 { 7939 ios.width(0); 7940 { 7941 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7942 std::string ex(str, iter.base()); 7943 assert(ex == "+0;0000000000000000"); 7944 assert(ios.width() == 0); 7945 } 7946 ios.width(25); 7947 left(ios); 7948 { 7949 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7950 std::string ex(str, iter.base()); 7951 assert(ex == "+0;0000000000000000******"); 7952 assert(ios.width() == 0); 7953 } 7954 ios.width(25); 7955 right(ios); 7956 { 7957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7958 std::string ex(str, iter.base()); 7959 assert(ex == "******+0;0000000000000000"); 7960 assert(ios.width() == 0); 7961 } 7962 ios.width(25); 7963 internal(ios); 7964 { 7965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7966 std::string ex(str, iter.base()); 7967 assert(ex == "+******0;0000000000000000"); 7968 assert(ios.width() == 0); 7969 } 7970 } 7971 } 7972 showpoint(ios); 7973 { 7974 ios.imbue(lc); 7975 { 7976 ios.width(0); 7977 { 7978 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7979 std::string ex(str, iter.base()); 7980 assert(ex == "+0.0000000000000000"); 7981 assert(ios.width() == 0); 7982 } 7983 ios.width(25); 7984 left(ios); 7985 { 7986 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7987 std::string ex(str, iter.base()); 7988 assert(ex == "+0.0000000000000000******"); 7989 assert(ios.width() == 0); 7990 } 7991 ios.width(25); 7992 right(ios); 7993 { 7994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 7995 std::string ex(str, iter.base()); 7996 assert(ex == "******+0.0000000000000000"); 7997 assert(ios.width() == 0); 7998 } 7999 ios.width(25); 8000 internal(ios); 8001 { 8002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8003 std::string ex(str, iter.base()); 8004 assert(ex == "+******0.0000000000000000"); 8005 assert(ios.width() == 0); 8006 } 8007 } 8008 ios.imbue(lg); 8009 { 8010 ios.width(0); 8011 { 8012 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8013 std::string ex(str, iter.base()); 8014 assert(ex == "+0;0000000000000000"); 8015 assert(ios.width() == 0); 8016 } 8017 ios.width(25); 8018 left(ios); 8019 { 8020 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8021 std::string ex(str, iter.base()); 8022 assert(ex == "+0;0000000000000000******"); 8023 assert(ios.width() == 0); 8024 } 8025 ios.width(25); 8026 right(ios); 8027 { 8028 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8029 std::string ex(str, iter.base()); 8030 assert(ex == "******+0;0000000000000000"); 8031 assert(ios.width() == 0); 8032 } 8033 ios.width(25); 8034 internal(ios); 8035 { 8036 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8037 std::string ex(str, iter.base()); 8038 assert(ex == "+******0;0000000000000000"); 8039 assert(ios.width() == 0); 8040 } 8041 } 8042 } 8043 } 8044 } 8045 uppercase(ios); 8046 { 8047 noshowpos(ios); 8048 { 8049 noshowpoint(ios); 8050 { 8051 ios.imbue(lc); 8052 { 8053 ios.width(0); 8054 { 8055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8056 std::string ex(str, iter.base()); 8057 assert(ex == "0.0000000000000000"); 8058 assert(ios.width() == 0); 8059 } 8060 ios.width(25); 8061 left(ios); 8062 { 8063 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8064 std::string ex(str, iter.base()); 8065 assert(ex == "0.0000000000000000*******"); 8066 assert(ios.width() == 0); 8067 } 8068 ios.width(25); 8069 right(ios); 8070 { 8071 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8072 std::string ex(str, iter.base()); 8073 assert(ex == "*******0.0000000000000000"); 8074 assert(ios.width() == 0); 8075 } 8076 ios.width(25); 8077 internal(ios); 8078 { 8079 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8080 std::string ex(str, iter.base()); 8081 assert(ex == "*******0.0000000000000000"); 8082 assert(ios.width() == 0); 8083 } 8084 } 8085 ios.imbue(lg); 8086 { 8087 ios.width(0); 8088 { 8089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8090 std::string ex(str, iter.base()); 8091 assert(ex == "0;0000000000000000"); 8092 assert(ios.width() == 0); 8093 } 8094 ios.width(25); 8095 left(ios); 8096 { 8097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8098 std::string ex(str, iter.base()); 8099 assert(ex == "0;0000000000000000*******"); 8100 assert(ios.width() == 0); 8101 } 8102 ios.width(25); 8103 right(ios); 8104 { 8105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8106 std::string ex(str, iter.base()); 8107 assert(ex == "*******0;0000000000000000"); 8108 assert(ios.width() == 0); 8109 } 8110 ios.width(25); 8111 internal(ios); 8112 { 8113 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8114 std::string ex(str, iter.base()); 8115 assert(ex == "*******0;0000000000000000"); 8116 assert(ios.width() == 0); 8117 } 8118 } 8119 } 8120 showpoint(ios); 8121 { 8122 ios.imbue(lc); 8123 { 8124 ios.width(0); 8125 { 8126 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8127 std::string ex(str, iter.base()); 8128 assert(ex == "0.0000000000000000"); 8129 assert(ios.width() == 0); 8130 } 8131 ios.width(25); 8132 left(ios); 8133 { 8134 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8135 std::string ex(str, iter.base()); 8136 assert(ex == "0.0000000000000000*******"); 8137 assert(ios.width() == 0); 8138 } 8139 ios.width(25); 8140 right(ios); 8141 { 8142 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8143 std::string ex(str, iter.base()); 8144 assert(ex == "*******0.0000000000000000"); 8145 assert(ios.width() == 0); 8146 } 8147 ios.width(25); 8148 internal(ios); 8149 { 8150 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8151 std::string ex(str, iter.base()); 8152 assert(ex == "*******0.0000000000000000"); 8153 assert(ios.width() == 0); 8154 } 8155 } 8156 ios.imbue(lg); 8157 { 8158 ios.width(0); 8159 { 8160 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8161 std::string ex(str, iter.base()); 8162 assert(ex == "0;0000000000000000"); 8163 assert(ios.width() == 0); 8164 } 8165 ios.width(25); 8166 left(ios); 8167 { 8168 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8169 std::string ex(str, iter.base()); 8170 assert(ex == "0;0000000000000000*******"); 8171 assert(ios.width() == 0); 8172 } 8173 ios.width(25); 8174 right(ios); 8175 { 8176 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8177 std::string ex(str, iter.base()); 8178 assert(ex == "*******0;0000000000000000"); 8179 assert(ios.width() == 0); 8180 } 8181 ios.width(25); 8182 internal(ios); 8183 { 8184 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8185 std::string ex(str, iter.base()); 8186 assert(ex == "*******0;0000000000000000"); 8187 assert(ios.width() == 0); 8188 } 8189 } 8190 } 8191 } 8192 showpos(ios); 8193 { 8194 noshowpoint(ios); 8195 { 8196 ios.imbue(lc); 8197 { 8198 ios.width(0); 8199 { 8200 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8201 std::string ex(str, iter.base()); 8202 assert(ex == "+0.0000000000000000"); 8203 assert(ios.width() == 0); 8204 } 8205 ios.width(25); 8206 left(ios); 8207 { 8208 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8209 std::string ex(str, iter.base()); 8210 assert(ex == "+0.0000000000000000******"); 8211 assert(ios.width() == 0); 8212 } 8213 ios.width(25); 8214 right(ios); 8215 { 8216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8217 std::string ex(str, iter.base()); 8218 assert(ex == "******+0.0000000000000000"); 8219 assert(ios.width() == 0); 8220 } 8221 ios.width(25); 8222 internal(ios); 8223 { 8224 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8225 std::string ex(str, iter.base()); 8226 assert(ex == "+******0.0000000000000000"); 8227 assert(ios.width() == 0); 8228 } 8229 } 8230 ios.imbue(lg); 8231 { 8232 ios.width(0); 8233 { 8234 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8235 std::string ex(str, iter.base()); 8236 assert(ex == "+0;0000000000000000"); 8237 assert(ios.width() == 0); 8238 } 8239 ios.width(25); 8240 left(ios); 8241 { 8242 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8243 std::string ex(str, iter.base()); 8244 assert(ex == "+0;0000000000000000******"); 8245 assert(ios.width() == 0); 8246 } 8247 ios.width(25); 8248 right(ios); 8249 { 8250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8251 std::string ex(str, iter.base()); 8252 assert(ex == "******+0;0000000000000000"); 8253 assert(ios.width() == 0); 8254 } 8255 ios.width(25); 8256 internal(ios); 8257 { 8258 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8259 std::string ex(str, iter.base()); 8260 assert(ex == "+******0;0000000000000000"); 8261 assert(ios.width() == 0); 8262 } 8263 } 8264 } 8265 showpoint(ios); 8266 { 8267 ios.imbue(lc); 8268 { 8269 ios.width(0); 8270 { 8271 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8272 std::string ex(str, iter.base()); 8273 assert(ex == "+0.0000000000000000"); 8274 assert(ios.width() == 0); 8275 } 8276 ios.width(25); 8277 left(ios); 8278 { 8279 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8280 std::string ex(str, iter.base()); 8281 assert(ex == "+0.0000000000000000******"); 8282 assert(ios.width() == 0); 8283 } 8284 ios.width(25); 8285 right(ios); 8286 { 8287 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8288 std::string ex(str, iter.base()); 8289 assert(ex == "******+0.0000000000000000"); 8290 assert(ios.width() == 0); 8291 } 8292 ios.width(25); 8293 internal(ios); 8294 { 8295 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8296 std::string ex(str, iter.base()); 8297 assert(ex == "+******0.0000000000000000"); 8298 assert(ios.width() == 0); 8299 } 8300 } 8301 ios.imbue(lg); 8302 { 8303 ios.width(0); 8304 { 8305 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8306 std::string ex(str, iter.base()); 8307 assert(ex == "+0;0000000000000000"); 8308 assert(ios.width() == 0); 8309 } 8310 ios.width(25); 8311 left(ios); 8312 { 8313 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8314 std::string ex(str, iter.base()); 8315 assert(ex == "+0;0000000000000000******"); 8316 assert(ios.width() == 0); 8317 } 8318 ios.width(25); 8319 right(ios); 8320 { 8321 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8322 std::string ex(str, iter.base()); 8323 assert(ex == "******+0;0000000000000000"); 8324 assert(ios.width() == 0); 8325 } 8326 ios.width(25); 8327 internal(ios); 8328 { 8329 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8330 std::string ex(str, iter.base()); 8331 assert(ex == "+******0;0000000000000000"); 8332 assert(ios.width() == 0); 8333 } 8334 } 8335 } 8336 } 8337 } 8338 } 8339 ios.precision(60); 8340 { 8341 nouppercase(ios); 8342 { 8343 noshowpos(ios); 8344 { 8345 noshowpoint(ios); 8346 { 8347 ios.imbue(lc); 8348 { 8349 ios.width(0); 8350 { 8351 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8352 std::string ex(str, iter.base()); 8353 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8354 assert(ios.width() == 0); 8355 } 8356 ios.width(25); 8357 left(ios); 8358 { 8359 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8360 std::string ex(str, iter.base()); 8361 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8362 assert(ios.width() == 0); 8363 } 8364 ios.width(25); 8365 right(ios); 8366 { 8367 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8368 std::string ex(str, iter.base()); 8369 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8370 assert(ios.width() == 0); 8371 } 8372 ios.width(25); 8373 internal(ios); 8374 { 8375 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8376 std::string ex(str, iter.base()); 8377 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8378 assert(ios.width() == 0); 8379 } 8380 } 8381 ios.imbue(lg); 8382 { 8383 ios.width(0); 8384 { 8385 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8386 std::string ex(str, iter.base()); 8387 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8388 assert(ios.width() == 0); 8389 } 8390 ios.width(25); 8391 left(ios); 8392 { 8393 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8394 std::string ex(str, iter.base()); 8395 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8396 assert(ios.width() == 0); 8397 } 8398 ios.width(25); 8399 right(ios); 8400 { 8401 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8402 std::string ex(str, iter.base()); 8403 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8404 assert(ios.width() == 0); 8405 } 8406 ios.width(25); 8407 internal(ios); 8408 { 8409 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8410 std::string ex(str, iter.base()); 8411 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8412 assert(ios.width() == 0); 8413 } 8414 } 8415 } 8416 showpoint(ios); 8417 { 8418 ios.imbue(lc); 8419 { 8420 ios.width(0); 8421 { 8422 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8423 std::string ex(str, iter.base()); 8424 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8425 assert(ios.width() == 0); 8426 } 8427 ios.width(25); 8428 left(ios); 8429 { 8430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8431 std::string ex(str, iter.base()); 8432 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8433 assert(ios.width() == 0); 8434 } 8435 ios.width(25); 8436 right(ios); 8437 { 8438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8439 std::string ex(str, iter.base()); 8440 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8441 assert(ios.width() == 0); 8442 } 8443 ios.width(25); 8444 internal(ios); 8445 { 8446 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8447 std::string ex(str, iter.base()); 8448 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8449 assert(ios.width() == 0); 8450 } 8451 } 8452 ios.imbue(lg); 8453 { 8454 ios.width(0); 8455 { 8456 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8457 std::string ex(str, iter.base()); 8458 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8459 assert(ios.width() == 0); 8460 } 8461 ios.width(25); 8462 left(ios); 8463 { 8464 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8465 std::string ex(str, iter.base()); 8466 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8467 assert(ios.width() == 0); 8468 } 8469 ios.width(25); 8470 right(ios); 8471 { 8472 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8473 std::string ex(str, iter.base()); 8474 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8475 assert(ios.width() == 0); 8476 } 8477 ios.width(25); 8478 internal(ios); 8479 { 8480 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8481 std::string ex(str, iter.base()); 8482 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8483 assert(ios.width() == 0); 8484 } 8485 } 8486 } 8487 } 8488 showpos(ios); 8489 { 8490 noshowpoint(ios); 8491 { 8492 ios.imbue(lc); 8493 { 8494 ios.width(0); 8495 { 8496 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8497 std::string ex(str, iter.base()); 8498 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8499 assert(ios.width() == 0); 8500 } 8501 ios.width(25); 8502 left(ios); 8503 { 8504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8505 std::string ex(str, iter.base()); 8506 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8507 assert(ios.width() == 0); 8508 } 8509 ios.width(25); 8510 right(ios); 8511 { 8512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8513 std::string ex(str, iter.base()); 8514 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8515 assert(ios.width() == 0); 8516 } 8517 ios.width(25); 8518 internal(ios); 8519 { 8520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8521 std::string ex(str, iter.base()); 8522 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8523 assert(ios.width() == 0); 8524 } 8525 } 8526 ios.imbue(lg); 8527 { 8528 ios.width(0); 8529 { 8530 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8531 std::string ex(str, iter.base()); 8532 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8533 assert(ios.width() == 0); 8534 } 8535 ios.width(25); 8536 left(ios); 8537 { 8538 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8539 std::string ex(str, iter.base()); 8540 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8541 assert(ios.width() == 0); 8542 } 8543 ios.width(25); 8544 right(ios); 8545 { 8546 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8547 std::string ex(str, iter.base()); 8548 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8549 assert(ios.width() == 0); 8550 } 8551 ios.width(25); 8552 internal(ios); 8553 { 8554 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8555 std::string ex(str, iter.base()); 8556 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8557 assert(ios.width() == 0); 8558 } 8559 } 8560 } 8561 showpoint(ios); 8562 { 8563 ios.imbue(lc); 8564 { 8565 ios.width(0); 8566 { 8567 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8568 std::string ex(str, iter.base()); 8569 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8570 assert(ios.width() == 0); 8571 } 8572 ios.width(25); 8573 left(ios); 8574 { 8575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8576 std::string ex(str, iter.base()); 8577 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8578 assert(ios.width() == 0); 8579 } 8580 ios.width(25); 8581 right(ios); 8582 { 8583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8584 std::string ex(str, iter.base()); 8585 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8586 assert(ios.width() == 0); 8587 } 8588 ios.width(25); 8589 internal(ios); 8590 { 8591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8592 std::string ex(str, iter.base()); 8593 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8594 assert(ios.width() == 0); 8595 } 8596 } 8597 ios.imbue(lg); 8598 { 8599 ios.width(0); 8600 { 8601 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8602 std::string ex(str, iter.base()); 8603 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8604 assert(ios.width() == 0); 8605 } 8606 ios.width(25); 8607 left(ios); 8608 { 8609 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8610 std::string ex(str, iter.base()); 8611 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8612 assert(ios.width() == 0); 8613 } 8614 ios.width(25); 8615 right(ios); 8616 { 8617 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8618 std::string ex(str, iter.base()); 8619 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8620 assert(ios.width() == 0); 8621 } 8622 ios.width(25); 8623 internal(ios); 8624 { 8625 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8626 std::string ex(str, iter.base()); 8627 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8628 assert(ios.width() == 0); 8629 } 8630 } 8631 } 8632 } 8633 } 8634 uppercase(ios); 8635 { 8636 noshowpos(ios); 8637 { 8638 noshowpoint(ios); 8639 { 8640 ios.imbue(lc); 8641 { 8642 ios.width(0); 8643 { 8644 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8645 std::string ex(str, iter.base()); 8646 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8647 assert(ios.width() == 0); 8648 } 8649 ios.width(25); 8650 left(ios); 8651 { 8652 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8653 std::string ex(str, iter.base()); 8654 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8655 assert(ios.width() == 0); 8656 } 8657 ios.width(25); 8658 right(ios); 8659 { 8660 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8661 std::string ex(str, iter.base()); 8662 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8663 assert(ios.width() == 0); 8664 } 8665 ios.width(25); 8666 internal(ios); 8667 { 8668 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8669 std::string ex(str, iter.base()); 8670 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8671 assert(ios.width() == 0); 8672 } 8673 } 8674 ios.imbue(lg); 8675 { 8676 ios.width(0); 8677 { 8678 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8679 std::string ex(str, iter.base()); 8680 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8681 assert(ios.width() == 0); 8682 } 8683 ios.width(25); 8684 left(ios); 8685 { 8686 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8687 std::string ex(str, iter.base()); 8688 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8689 assert(ios.width() == 0); 8690 } 8691 ios.width(25); 8692 right(ios); 8693 { 8694 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8695 std::string ex(str, iter.base()); 8696 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8697 assert(ios.width() == 0); 8698 } 8699 ios.width(25); 8700 internal(ios); 8701 { 8702 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8703 std::string ex(str, iter.base()); 8704 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8705 assert(ios.width() == 0); 8706 } 8707 } 8708 } 8709 showpoint(ios); 8710 { 8711 ios.imbue(lc); 8712 { 8713 ios.width(0); 8714 { 8715 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8716 std::string ex(str, iter.base()); 8717 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8718 assert(ios.width() == 0); 8719 } 8720 ios.width(25); 8721 left(ios); 8722 { 8723 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8724 std::string ex(str, iter.base()); 8725 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8726 assert(ios.width() == 0); 8727 } 8728 ios.width(25); 8729 right(ios); 8730 { 8731 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8732 std::string ex(str, iter.base()); 8733 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8734 assert(ios.width() == 0); 8735 } 8736 ios.width(25); 8737 internal(ios); 8738 { 8739 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8740 std::string ex(str, iter.base()); 8741 assert(ex == "0.000000000000000000000000000000000000000000000000000000000000"); 8742 assert(ios.width() == 0); 8743 } 8744 } 8745 ios.imbue(lg); 8746 { 8747 ios.width(0); 8748 { 8749 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8750 std::string ex(str, iter.base()); 8751 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8752 assert(ios.width() == 0); 8753 } 8754 ios.width(25); 8755 left(ios); 8756 { 8757 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8758 std::string ex(str, iter.base()); 8759 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8760 assert(ios.width() == 0); 8761 } 8762 ios.width(25); 8763 right(ios); 8764 { 8765 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8766 std::string ex(str, iter.base()); 8767 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8768 assert(ios.width() == 0); 8769 } 8770 ios.width(25); 8771 internal(ios); 8772 { 8773 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8774 std::string ex(str, iter.base()); 8775 assert(ex == "0;000000000000000000000000000000000000000000000000000000000000"); 8776 assert(ios.width() == 0); 8777 } 8778 } 8779 } 8780 } 8781 showpos(ios); 8782 { 8783 noshowpoint(ios); 8784 { 8785 ios.imbue(lc); 8786 { 8787 ios.width(0); 8788 { 8789 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8790 std::string ex(str, iter.base()); 8791 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8792 assert(ios.width() == 0); 8793 } 8794 ios.width(25); 8795 left(ios); 8796 { 8797 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8798 std::string ex(str, iter.base()); 8799 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8800 assert(ios.width() == 0); 8801 } 8802 ios.width(25); 8803 right(ios); 8804 { 8805 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8806 std::string ex(str, iter.base()); 8807 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8808 assert(ios.width() == 0); 8809 } 8810 ios.width(25); 8811 internal(ios); 8812 { 8813 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8814 std::string ex(str, iter.base()); 8815 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8816 assert(ios.width() == 0); 8817 } 8818 } 8819 ios.imbue(lg); 8820 { 8821 ios.width(0); 8822 { 8823 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8824 std::string ex(str, iter.base()); 8825 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8826 assert(ios.width() == 0); 8827 } 8828 ios.width(25); 8829 left(ios); 8830 { 8831 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8832 std::string ex(str, iter.base()); 8833 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8834 assert(ios.width() == 0); 8835 } 8836 ios.width(25); 8837 right(ios); 8838 { 8839 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8840 std::string ex(str, iter.base()); 8841 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8842 assert(ios.width() == 0); 8843 } 8844 ios.width(25); 8845 internal(ios); 8846 { 8847 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8848 std::string ex(str, iter.base()); 8849 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8850 assert(ios.width() == 0); 8851 } 8852 } 8853 } 8854 showpoint(ios); 8855 { 8856 ios.imbue(lc); 8857 { 8858 ios.width(0); 8859 { 8860 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8861 std::string ex(str, iter.base()); 8862 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8863 assert(ios.width() == 0); 8864 } 8865 ios.width(25); 8866 left(ios); 8867 { 8868 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8869 std::string ex(str, iter.base()); 8870 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8871 assert(ios.width() == 0); 8872 } 8873 ios.width(25); 8874 right(ios); 8875 { 8876 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8877 std::string ex(str, iter.base()); 8878 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8879 assert(ios.width() == 0); 8880 } 8881 ios.width(25); 8882 internal(ios); 8883 { 8884 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8885 std::string ex(str, iter.base()); 8886 assert(ex == "+0.000000000000000000000000000000000000000000000000000000000000"); 8887 assert(ios.width() == 0); 8888 } 8889 } 8890 ios.imbue(lg); 8891 { 8892 ios.width(0); 8893 { 8894 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8895 std::string ex(str, iter.base()); 8896 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8897 assert(ios.width() == 0); 8898 } 8899 ios.width(25); 8900 left(ios); 8901 { 8902 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8903 std::string ex(str, iter.base()); 8904 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8905 assert(ios.width() == 0); 8906 } 8907 ios.width(25); 8908 right(ios); 8909 { 8910 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8911 std::string ex(str, iter.base()); 8912 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8913 assert(ios.width() == 0); 8914 } 8915 ios.width(25); 8916 internal(ios); 8917 { 8918 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8919 std::string ex(str, iter.base()); 8920 assert(ex == "+0;000000000000000000000000000000000000000000000000000000000000"); 8921 assert(ios.width() == 0); 8922 } 8923 } 8924 } 8925 } 8926 } 8927 } 8928 } 8929 } 8930 } 8931 8932 void test4() 8933 { 8934 char str[200]; 8935 output_iterator<char*> iter; 8936 std::locale lc = std::locale::classic(); 8937 std::locale lg(lc, new my_numpunct); 8938 const my_facet f(1); 8939 { 8940 double v = 1234567890.125; 8941 std::ios ios(0); 8942 fixed(ios); 8943 // %f 8944 { 8945 ios.precision(0); 8946 { 8947 nouppercase(ios); 8948 { 8949 noshowpos(ios); 8950 { 8951 noshowpoint(ios); 8952 { 8953 ios.imbue(lc); 8954 { 8955 ios.width(0); 8956 { 8957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8958 std::string ex(str, iter.base()); 8959 assert(ex == "1234567890"); 8960 assert(ios.width() == 0); 8961 } 8962 ios.width(25); 8963 left(ios); 8964 { 8965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8966 std::string ex(str, iter.base()); 8967 assert(ex == "1234567890***************"); 8968 assert(ios.width() == 0); 8969 } 8970 ios.width(25); 8971 right(ios); 8972 { 8973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8974 std::string ex(str, iter.base()); 8975 assert(ex == "***************1234567890"); 8976 assert(ios.width() == 0); 8977 } 8978 ios.width(25); 8979 internal(ios); 8980 { 8981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8982 std::string ex(str, iter.base()); 8983 assert(ex == "***************1234567890"); 8984 assert(ios.width() == 0); 8985 } 8986 } 8987 ios.imbue(lg); 8988 { 8989 ios.width(0); 8990 { 8991 iter = f.put(output_iterator<char*>(str), ios, '*', v); 8992 std::string ex(str, iter.base()); 8993 assert(ex == "1_234_567_89_0"); 8994 assert(ios.width() == 0); 8995 } 8996 ios.width(25); 8997 left(ios); 8998 { 8999 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9000 std::string ex(str, iter.base()); 9001 assert(ex == "1_234_567_89_0***********"); 9002 assert(ios.width() == 0); 9003 } 9004 ios.width(25); 9005 right(ios); 9006 { 9007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9008 std::string ex(str, iter.base()); 9009 assert(ex == "***********1_234_567_89_0"); 9010 assert(ios.width() == 0); 9011 } 9012 ios.width(25); 9013 internal(ios); 9014 { 9015 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9016 std::string ex(str, iter.base()); 9017 assert(ex == "***********1_234_567_89_0"); 9018 assert(ios.width() == 0); 9019 } 9020 } 9021 } 9022 showpoint(ios); 9023 { 9024 ios.imbue(lc); 9025 { 9026 ios.width(0); 9027 { 9028 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9029 std::string ex(str, iter.base()); 9030 assert(ex == "1234567890."); 9031 assert(ios.width() == 0); 9032 } 9033 ios.width(25); 9034 left(ios); 9035 { 9036 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9037 std::string ex(str, iter.base()); 9038 assert(ex == "1234567890.**************"); 9039 assert(ios.width() == 0); 9040 } 9041 ios.width(25); 9042 right(ios); 9043 { 9044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9045 std::string ex(str, iter.base()); 9046 assert(ex == "**************1234567890."); 9047 assert(ios.width() == 0); 9048 } 9049 ios.width(25); 9050 internal(ios); 9051 { 9052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9053 std::string ex(str, iter.base()); 9054 assert(ex == "**************1234567890."); 9055 assert(ios.width() == 0); 9056 } 9057 } 9058 ios.imbue(lg); 9059 { 9060 ios.width(0); 9061 { 9062 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9063 std::string ex(str, iter.base()); 9064 assert(ex == "1_234_567_89_0;"); 9065 assert(ios.width() == 0); 9066 } 9067 ios.width(25); 9068 left(ios); 9069 { 9070 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9071 std::string ex(str, iter.base()); 9072 assert(ex == "1_234_567_89_0;**********"); 9073 assert(ios.width() == 0); 9074 } 9075 ios.width(25); 9076 right(ios); 9077 { 9078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9079 std::string ex(str, iter.base()); 9080 assert(ex == "**********1_234_567_89_0;"); 9081 assert(ios.width() == 0); 9082 } 9083 ios.width(25); 9084 internal(ios); 9085 { 9086 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9087 std::string ex(str, iter.base()); 9088 assert(ex == "**********1_234_567_89_0;"); 9089 assert(ios.width() == 0); 9090 } 9091 } 9092 } 9093 } 9094 showpos(ios); 9095 { 9096 noshowpoint(ios); 9097 { 9098 ios.imbue(lc); 9099 { 9100 ios.width(0); 9101 { 9102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9103 std::string ex(str, iter.base()); 9104 assert(ex == "+1234567890"); 9105 assert(ios.width() == 0); 9106 } 9107 ios.width(25); 9108 left(ios); 9109 { 9110 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9111 std::string ex(str, iter.base()); 9112 assert(ex == "+1234567890**************"); 9113 assert(ios.width() == 0); 9114 } 9115 ios.width(25); 9116 right(ios); 9117 { 9118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9119 std::string ex(str, iter.base()); 9120 assert(ex == "**************+1234567890"); 9121 assert(ios.width() == 0); 9122 } 9123 ios.width(25); 9124 internal(ios); 9125 { 9126 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9127 std::string ex(str, iter.base()); 9128 assert(ex == "+**************1234567890"); 9129 assert(ios.width() == 0); 9130 } 9131 } 9132 ios.imbue(lg); 9133 { 9134 ios.width(0); 9135 { 9136 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9137 std::string ex(str, iter.base()); 9138 assert(ex == "+1_234_567_89_0"); 9139 assert(ios.width() == 0); 9140 } 9141 ios.width(25); 9142 left(ios); 9143 { 9144 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9145 std::string ex(str, iter.base()); 9146 assert(ex == "+1_234_567_89_0**********"); 9147 assert(ios.width() == 0); 9148 } 9149 ios.width(25); 9150 right(ios); 9151 { 9152 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9153 std::string ex(str, iter.base()); 9154 assert(ex == "**********+1_234_567_89_0"); 9155 assert(ios.width() == 0); 9156 } 9157 ios.width(25); 9158 internal(ios); 9159 { 9160 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9161 std::string ex(str, iter.base()); 9162 assert(ex == "+**********1_234_567_89_0"); 9163 assert(ios.width() == 0); 9164 } 9165 } 9166 } 9167 showpoint(ios); 9168 { 9169 ios.imbue(lc); 9170 { 9171 ios.width(0); 9172 { 9173 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9174 std::string ex(str, iter.base()); 9175 assert(ex == "+1234567890."); 9176 assert(ios.width() == 0); 9177 } 9178 ios.width(25); 9179 left(ios); 9180 { 9181 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9182 std::string ex(str, iter.base()); 9183 assert(ex == "+1234567890.*************"); 9184 assert(ios.width() == 0); 9185 } 9186 ios.width(25); 9187 right(ios); 9188 { 9189 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9190 std::string ex(str, iter.base()); 9191 assert(ex == "*************+1234567890."); 9192 assert(ios.width() == 0); 9193 } 9194 ios.width(25); 9195 internal(ios); 9196 { 9197 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9198 std::string ex(str, iter.base()); 9199 assert(ex == "+*************1234567890."); 9200 assert(ios.width() == 0); 9201 } 9202 } 9203 ios.imbue(lg); 9204 { 9205 ios.width(0); 9206 { 9207 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9208 std::string ex(str, iter.base()); 9209 assert(ex == "+1_234_567_89_0;"); 9210 assert(ios.width() == 0); 9211 } 9212 ios.width(25); 9213 left(ios); 9214 { 9215 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9216 std::string ex(str, iter.base()); 9217 assert(ex == "+1_234_567_89_0;*********"); 9218 assert(ios.width() == 0); 9219 } 9220 ios.width(25); 9221 right(ios); 9222 { 9223 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9224 std::string ex(str, iter.base()); 9225 assert(ex == "*********+1_234_567_89_0;"); 9226 assert(ios.width() == 0); 9227 } 9228 ios.width(25); 9229 internal(ios); 9230 { 9231 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9232 std::string ex(str, iter.base()); 9233 assert(ex == "+*********1_234_567_89_0;"); 9234 assert(ios.width() == 0); 9235 } 9236 } 9237 } 9238 } 9239 } 9240 uppercase(ios); 9241 { 9242 noshowpos(ios); 9243 { 9244 noshowpoint(ios); 9245 { 9246 ios.imbue(lc); 9247 { 9248 ios.width(0); 9249 { 9250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9251 std::string ex(str, iter.base()); 9252 assert(ex == "1234567890"); 9253 assert(ios.width() == 0); 9254 } 9255 ios.width(25); 9256 left(ios); 9257 { 9258 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9259 std::string ex(str, iter.base()); 9260 assert(ex == "1234567890***************"); 9261 assert(ios.width() == 0); 9262 } 9263 ios.width(25); 9264 right(ios); 9265 { 9266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9267 std::string ex(str, iter.base()); 9268 assert(ex == "***************1234567890"); 9269 assert(ios.width() == 0); 9270 } 9271 ios.width(25); 9272 internal(ios); 9273 { 9274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9275 std::string ex(str, iter.base()); 9276 assert(ex == "***************1234567890"); 9277 assert(ios.width() == 0); 9278 } 9279 } 9280 ios.imbue(lg); 9281 { 9282 ios.width(0); 9283 { 9284 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9285 std::string ex(str, iter.base()); 9286 assert(ex == "1_234_567_89_0"); 9287 assert(ios.width() == 0); 9288 } 9289 ios.width(25); 9290 left(ios); 9291 { 9292 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9293 std::string ex(str, iter.base()); 9294 assert(ex == "1_234_567_89_0***********"); 9295 assert(ios.width() == 0); 9296 } 9297 ios.width(25); 9298 right(ios); 9299 { 9300 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9301 std::string ex(str, iter.base()); 9302 assert(ex == "***********1_234_567_89_0"); 9303 assert(ios.width() == 0); 9304 } 9305 ios.width(25); 9306 internal(ios); 9307 { 9308 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9309 std::string ex(str, iter.base()); 9310 assert(ex == "***********1_234_567_89_0"); 9311 assert(ios.width() == 0); 9312 } 9313 } 9314 } 9315 showpoint(ios); 9316 { 9317 ios.imbue(lc); 9318 { 9319 ios.width(0); 9320 { 9321 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9322 std::string ex(str, iter.base()); 9323 assert(ex == "1234567890."); 9324 assert(ios.width() == 0); 9325 } 9326 ios.width(25); 9327 left(ios); 9328 { 9329 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9330 std::string ex(str, iter.base()); 9331 assert(ex == "1234567890.**************"); 9332 assert(ios.width() == 0); 9333 } 9334 ios.width(25); 9335 right(ios); 9336 { 9337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9338 std::string ex(str, iter.base()); 9339 assert(ex == "**************1234567890."); 9340 assert(ios.width() == 0); 9341 } 9342 ios.width(25); 9343 internal(ios); 9344 { 9345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9346 std::string ex(str, iter.base()); 9347 assert(ex == "**************1234567890."); 9348 assert(ios.width() == 0); 9349 } 9350 } 9351 ios.imbue(lg); 9352 { 9353 ios.width(0); 9354 { 9355 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9356 std::string ex(str, iter.base()); 9357 assert(ex == "1_234_567_89_0;"); 9358 assert(ios.width() == 0); 9359 } 9360 ios.width(25); 9361 left(ios); 9362 { 9363 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9364 std::string ex(str, iter.base()); 9365 assert(ex == "1_234_567_89_0;**********"); 9366 assert(ios.width() == 0); 9367 } 9368 ios.width(25); 9369 right(ios); 9370 { 9371 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9372 std::string ex(str, iter.base()); 9373 assert(ex == "**********1_234_567_89_0;"); 9374 assert(ios.width() == 0); 9375 } 9376 ios.width(25); 9377 internal(ios); 9378 { 9379 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9380 std::string ex(str, iter.base()); 9381 assert(ex == "**********1_234_567_89_0;"); 9382 assert(ios.width() == 0); 9383 } 9384 } 9385 } 9386 } 9387 showpos(ios); 9388 { 9389 noshowpoint(ios); 9390 { 9391 ios.imbue(lc); 9392 { 9393 ios.width(0); 9394 { 9395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9396 std::string ex(str, iter.base()); 9397 assert(ex == "+1234567890"); 9398 assert(ios.width() == 0); 9399 } 9400 ios.width(25); 9401 left(ios); 9402 { 9403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9404 std::string ex(str, iter.base()); 9405 assert(ex == "+1234567890**************"); 9406 assert(ios.width() == 0); 9407 } 9408 ios.width(25); 9409 right(ios); 9410 { 9411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9412 std::string ex(str, iter.base()); 9413 assert(ex == "**************+1234567890"); 9414 assert(ios.width() == 0); 9415 } 9416 ios.width(25); 9417 internal(ios); 9418 { 9419 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9420 std::string ex(str, iter.base()); 9421 assert(ex == "+**************1234567890"); 9422 assert(ios.width() == 0); 9423 } 9424 } 9425 ios.imbue(lg); 9426 { 9427 ios.width(0); 9428 { 9429 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9430 std::string ex(str, iter.base()); 9431 assert(ex == "+1_234_567_89_0"); 9432 assert(ios.width() == 0); 9433 } 9434 ios.width(25); 9435 left(ios); 9436 { 9437 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9438 std::string ex(str, iter.base()); 9439 assert(ex == "+1_234_567_89_0**********"); 9440 assert(ios.width() == 0); 9441 } 9442 ios.width(25); 9443 right(ios); 9444 { 9445 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9446 std::string ex(str, iter.base()); 9447 assert(ex == "**********+1_234_567_89_0"); 9448 assert(ios.width() == 0); 9449 } 9450 ios.width(25); 9451 internal(ios); 9452 { 9453 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9454 std::string ex(str, iter.base()); 9455 assert(ex == "+**********1_234_567_89_0"); 9456 assert(ios.width() == 0); 9457 } 9458 } 9459 } 9460 showpoint(ios); 9461 { 9462 ios.imbue(lc); 9463 { 9464 ios.width(0); 9465 { 9466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9467 std::string ex(str, iter.base()); 9468 assert(ex == "+1234567890."); 9469 assert(ios.width() == 0); 9470 } 9471 ios.width(25); 9472 left(ios); 9473 { 9474 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9475 std::string ex(str, iter.base()); 9476 assert(ex == "+1234567890.*************"); 9477 assert(ios.width() == 0); 9478 } 9479 ios.width(25); 9480 right(ios); 9481 { 9482 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9483 std::string ex(str, iter.base()); 9484 assert(ex == "*************+1234567890."); 9485 assert(ios.width() == 0); 9486 } 9487 ios.width(25); 9488 internal(ios); 9489 { 9490 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9491 std::string ex(str, iter.base()); 9492 assert(ex == "+*************1234567890."); 9493 assert(ios.width() == 0); 9494 } 9495 } 9496 ios.imbue(lg); 9497 { 9498 ios.width(0); 9499 { 9500 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9501 std::string ex(str, iter.base()); 9502 assert(ex == "+1_234_567_89_0;"); 9503 assert(ios.width() == 0); 9504 } 9505 ios.width(25); 9506 left(ios); 9507 { 9508 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9509 std::string ex(str, iter.base()); 9510 assert(ex == "+1_234_567_89_0;*********"); 9511 assert(ios.width() == 0); 9512 } 9513 ios.width(25); 9514 right(ios); 9515 { 9516 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9517 std::string ex(str, iter.base()); 9518 assert(ex == "*********+1_234_567_89_0;"); 9519 assert(ios.width() == 0); 9520 } 9521 ios.width(25); 9522 internal(ios); 9523 { 9524 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9525 std::string ex(str, iter.base()); 9526 assert(ex == "+*********1_234_567_89_0;"); 9527 assert(ios.width() == 0); 9528 } 9529 } 9530 } 9531 } 9532 } 9533 } 9534 ios.precision(1); 9535 { 9536 nouppercase(ios); 9537 { 9538 noshowpos(ios); 9539 { 9540 noshowpoint(ios); 9541 { 9542 ios.imbue(lc); 9543 { 9544 ios.width(0); 9545 { 9546 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9547 std::string ex(str, iter.base()); 9548 assert(ex == "1234567890.1"); 9549 assert(ios.width() == 0); 9550 } 9551 ios.width(25); 9552 left(ios); 9553 { 9554 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9555 std::string ex(str, iter.base()); 9556 assert(ex == "1234567890.1*************"); 9557 assert(ios.width() == 0); 9558 } 9559 ios.width(25); 9560 right(ios); 9561 { 9562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9563 std::string ex(str, iter.base()); 9564 assert(ex == "*************1234567890.1"); 9565 assert(ios.width() == 0); 9566 } 9567 ios.width(25); 9568 internal(ios); 9569 { 9570 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9571 std::string ex(str, iter.base()); 9572 assert(ex == "*************1234567890.1"); 9573 assert(ios.width() == 0); 9574 } 9575 } 9576 ios.imbue(lg); 9577 { 9578 ios.width(0); 9579 { 9580 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9581 std::string ex(str, iter.base()); 9582 assert(ex == "1_234_567_89_0;1"); 9583 assert(ios.width() == 0); 9584 } 9585 ios.width(25); 9586 left(ios); 9587 { 9588 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9589 std::string ex(str, iter.base()); 9590 assert(ex == "1_234_567_89_0;1*********"); 9591 assert(ios.width() == 0); 9592 } 9593 ios.width(25); 9594 right(ios); 9595 { 9596 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9597 std::string ex(str, iter.base()); 9598 assert(ex == "*********1_234_567_89_0;1"); 9599 assert(ios.width() == 0); 9600 } 9601 ios.width(25); 9602 internal(ios); 9603 { 9604 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9605 std::string ex(str, iter.base()); 9606 assert(ex == "*********1_234_567_89_0;1"); 9607 assert(ios.width() == 0); 9608 } 9609 } 9610 } 9611 showpoint(ios); 9612 { 9613 ios.imbue(lc); 9614 { 9615 ios.width(0); 9616 { 9617 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9618 std::string ex(str, iter.base()); 9619 assert(ex == "1234567890.1"); 9620 assert(ios.width() == 0); 9621 } 9622 ios.width(25); 9623 left(ios); 9624 { 9625 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9626 std::string ex(str, iter.base()); 9627 assert(ex == "1234567890.1*************"); 9628 assert(ios.width() == 0); 9629 } 9630 ios.width(25); 9631 right(ios); 9632 { 9633 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9634 std::string ex(str, iter.base()); 9635 assert(ex == "*************1234567890.1"); 9636 assert(ios.width() == 0); 9637 } 9638 ios.width(25); 9639 internal(ios); 9640 { 9641 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9642 std::string ex(str, iter.base()); 9643 assert(ex == "*************1234567890.1"); 9644 assert(ios.width() == 0); 9645 } 9646 } 9647 ios.imbue(lg); 9648 { 9649 ios.width(0); 9650 { 9651 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9652 std::string ex(str, iter.base()); 9653 assert(ex == "1_234_567_89_0;1"); 9654 assert(ios.width() == 0); 9655 } 9656 ios.width(25); 9657 left(ios); 9658 { 9659 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9660 std::string ex(str, iter.base()); 9661 assert(ex == "1_234_567_89_0;1*********"); 9662 assert(ios.width() == 0); 9663 } 9664 ios.width(25); 9665 right(ios); 9666 { 9667 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9668 std::string ex(str, iter.base()); 9669 assert(ex == "*********1_234_567_89_0;1"); 9670 assert(ios.width() == 0); 9671 } 9672 ios.width(25); 9673 internal(ios); 9674 { 9675 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9676 std::string ex(str, iter.base()); 9677 assert(ex == "*********1_234_567_89_0;1"); 9678 assert(ios.width() == 0); 9679 } 9680 } 9681 } 9682 } 9683 showpos(ios); 9684 { 9685 noshowpoint(ios); 9686 { 9687 ios.imbue(lc); 9688 { 9689 ios.width(0); 9690 { 9691 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9692 std::string ex(str, iter.base()); 9693 assert(ex == "+1234567890.1"); 9694 assert(ios.width() == 0); 9695 } 9696 ios.width(25); 9697 left(ios); 9698 { 9699 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9700 std::string ex(str, iter.base()); 9701 assert(ex == "+1234567890.1************"); 9702 assert(ios.width() == 0); 9703 } 9704 ios.width(25); 9705 right(ios); 9706 { 9707 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9708 std::string ex(str, iter.base()); 9709 assert(ex == "************+1234567890.1"); 9710 assert(ios.width() == 0); 9711 } 9712 ios.width(25); 9713 internal(ios); 9714 { 9715 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9716 std::string ex(str, iter.base()); 9717 assert(ex == "+************1234567890.1"); 9718 assert(ios.width() == 0); 9719 } 9720 } 9721 ios.imbue(lg); 9722 { 9723 ios.width(0); 9724 { 9725 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9726 std::string ex(str, iter.base()); 9727 assert(ex == "+1_234_567_89_0;1"); 9728 assert(ios.width() == 0); 9729 } 9730 ios.width(25); 9731 left(ios); 9732 { 9733 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9734 std::string ex(str, iter.base()); 9735 assert(ex == "+1_234_567_89_0;1********"); 9736 assert(ios.width() == 0); 9737 } 9738 ios.width(25); 9739 right(ios); 9740 { 9741 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9742 std::string ex(str, iter.base()); 9743 assert(ex == "********+1_234_567_89_0;1"); 9744 assert(ios.width() == 0); 9745 } 9746 ios.width(25); 9747 internal(ios); 9748 { 9749 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9750 std::string ex(str, iter.base()); 9751 assert(ex == "+********1_234_567_89_0;1"); 9752 assert(ios.width() == 0); 9753 } 9754 } 9755 } 9756 showpoint(ios); 9757 { 9758 ios.imbue(lc); 9759 { 9760 ios.width(0); 9761 { 9762 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9763 std::string ex(str, iter.base()); 9764 assert(ex == "+1234567890.1"); 9765 assert(ios.width() == 0); 9766 } 9767 ios.width(25); 9768 left(ios); 9769 { 9770 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9771 std::string ex(str, iter.base()); 9772 assert(ex == "+1234567890.1************"); 9773 assert(ios.width() == 0); 9774 } 9775 ios.width(25); 9776 right(ios); 9777 { 9778 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9779 std::string ex(str, iter.base()); 9780 assert(ex == "************+1234567890.1"); 9781 assert(ios.width() == 0); 9782 } 9783 ios.width(25); 9784 internal(ios); 9785 { 9786 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9787 std::string ex(str, iter.base()); 9788 assert(ex == "+************1234567890.1"); 9789 assert(ios.width() == 0); 9790 } 9791 } 9792 ios.imbue(lg); 9793 { 9794 ios.width(0); 9795 { 9796 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9797 std::string ex(str, iter.base()); 9798 assert(ex == "+1_234_567_89_0;1"); 9799 assert(ios.width() == 0); 9800 } 9801 ios.width(25); 9802 left(ios); 9803 { 9804 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9805 std::string ex(str, iter.base()); 9806 assert(ex == "+1_234_567_89_0;1********"); 9807 assert(ios.width() == 0); 9808 } 9809 ios.width(25); 9810 right(ios); 9811 { 9812 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9813 std::string ex(str, iter.base()); 9814 assert(ex == "********+1_234_567_89_0;1"); 9815 assert(ios.width() == 0); 9816 } 9817 ios.width(25); 9818 internal(ios); 9819 { 9820 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9821 std::string ex(str, iter.base()); 9822 assert(ex == "+********1_234_567_89_0;1"); 9823 assert(ios.width() == 0); 9824 } 9825 } 9826 } 9827 } 9828 } 9829 uppercase(ios); 9830 { 9831 noshowpos(ios); 9832 { 9833 noshowpoint(ios); 9834 { 9835 ios.imbue(lc); 9836 { 9837 ios.width(0); 9838 { 9839 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9840 std::string ex(str, iter.base()); 9841 assert(ex == "1234567890.1"); 9842 assert(ios.width() == 0); 9843 } 9844 ios.width(25); 9845 left(ios); 9846 { 9847 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9848 std::string ex(str, iter.base()); 9849 assert(ex == "1234567890.1*************"); 9850 assert(ios.width() == 0); 9851 } 9852 ios.width(25); 9853 right(ios); 9854 { 9855 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9856 std::string ex(str, iter.base()); 9857 assert(ex == "*************1234567890.1"); 9858 assert(ios.width() == 0); 9859 } 9860 ios.width(25); 9861 internal(ios); 9862 { 9863 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9864 std::string ex(str, iter.base()); 9865 assert(ex == "*************1234567890.1"); 9866 assert(ios.width() == 0); 9867 } 9868 } 9869 ios.imbue(lg); 9870 { 9871 ios.width(0); 9872 { 9873 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9874 std::string ex(str, iter.base()); 9875 assert(ex == "1_234_567_89_0;1"); 9876 assert(ios.width() == 0); 9877 } 9878 ios.width(25); 9879 left(ios); 9880 { 9881 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9882 std::string ex(str, iter.base()); 9883 assert(ex == "1_234_567_89_0;1*********"); 9884 assert(ios.width() == 0); 9885 } 9886 ios.width(25); 9887 right(ios); 9888 { 9889 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9890 std::string ex(str, iter.base()); 9891 assert(ex == "*********1_234_567_89_0;1"); 9892 assert(ios.width() == 0); 9893 } 9894 ios.width(25); 9895 internal(ios); 9896 { 9897 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9898 std::string ex(str, iter.base()); 9899 assert(ex == "*********1_234_567_89_0;1"); 9900 assert(ios.width() == 0); 9901 } 9902 } 9903 } 9904 showpoint(ios); 9905 { 9906 ios.imbue(lc); 9907 { 9908 ios.width(0); 9909 { 9910 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9911 std::string ex(str, iter.base()); 9912 assert(ex == "1234567890.1"); 9913 assert(ios.width() == 0); 9914 } 9915 ios.width(25); 9916 left(ios); 9917 { 9918 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9919 std::string ex(str, iter.base()); 9920 assert(ex == "1234567890.1*************"); 9921 assert(ios.width() == 0); 9922 } 9923 ios.width(25); 9924 right(ios); 9925 { 9926 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9927 std::string ex(str, iter.base()); 9928 assert(ex == "*************1234567890.1"); 9929 assert(ios.width() == 0); 9930 } 9931 ios.width(25); 9932 internal(ios); 9933 { 9934 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9935 std::string ex(str, iter.base()); 9936 assert(ex == "*************1234567890.1"); 9937 assert(ios.width() == 0); 9938 } 9939 } 9940 ios.imbue(lg); 9941 { 9942 ios.width(0); 9943 { 9944 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9945 std::string ex(str, iter.base()); 9946 assert(ex == "1_234_567_89_0;1"); 9947 assert(ios.width() == 0); 9948 } 9949 ios.width(25); 9950 left(ios); 9951 { 9952 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9953 std::string ex(str, iter.base()); 9954 assert(ex == "1_234_567_89_0;1*********"); 9955 assert(ios.width() == 0); 9956 } 9957 ios.width(25); 9958 right(ios); 9959 { 9960 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9961 std::string ex(str, iter.base()); 9962 assert(ex == "*********1_234_567_89_0;1"); 9963 assert(ios.width() == 0); 9964 } 9965 ios.width(25); 9966 internal(ios); 9967 { 9968 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9969 std::string ex(str, iter.base()); 9970 assert(ex == "*********1_234_567_89_0;1"); 9971 assert(ios.width() == 0); 9972 } 9973 } 9974 } 9975 } 9976 showpos(ios); 9977 { 9978 noshowpoint(ios); 9979 { 9980 ios.imbue(lc); 9981 { 9982 ios.width(0); 9983 { 9984 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9985 std::string ex(str, iter.base()); 9986 assert(ex == "+1234567890.1"); 9987 assert(ios.width() == 0); 9988 } 9989 ios.width(25); 9990 left(ios); 9991 { 9992 iter = f.put(output_iterator<char*>(str), ios, '*', v); 9993 std::string ex(str, iter.base()); 9994 assert(ex == "+1234567890.1************"); 9995 assert(ios.width() == 0); 9996 } 9997 ios.width(25); 9998 right(ios); 9999 { 10000 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10001 std::string ex(str, iter.base()); 10002 assert(ex == "************+1234567890.1"); 10003 assert(ios.width() == 0); 10004 } 10005 ios.width(25); 10006 internal(ios); 10007 { 10008 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10009 std::string ex(str, iter.base()); 10010 assert(ex == "+************1234567890.1"); 10011 assert(ios.width() == 0); 10012 } 10013 } 10014 ios.imbue(lg); 10015 { 10016 ios.width(0); 10017 { 10018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10019 std::string ex(str, iter.base()); 10020 assert(ex == "+1_234_567_89_0;1"); 10021 assert(ios.width() == 0); 10022 } 10023 ios.width(25); 10024 left(ios); 10025 { 10026 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10027 std::string ex(str, iter.base()); 10028 assert(ex == "+1_234_567_89_0;1********"); 10029 assert(ios.width() == 0); 10030 } 10031 ios.width(25); 10032 right(ios); 10033 { 10034 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10035 std::string ex(str, iter.base()); 10036 assert(ex == "********+1_234_567_89_0;1"); 10037 assert(ios.width() == 0); 10038 } 10039 ios.width(25); 10040 internal(ios); 10041 { 10042 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10043 std::string ex(str, iter.base()); 10044 assert(ex == "+********1_234_567_89_0;1"); 10045 assert(ios.width() == 0); 10046 } 10047 } 10048 } 10049 showpoint(ios); 10050 { 10051 ios.imbue(lc); 10052 { 10053 ios.width(0); 10054 { 10055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10056 std::string ex(str, iter.base()); 10057 assert(ex == "+1234567890.1"); 10058 assert(ios.width() == 0); 10059 } 10060 ios.width(25); 10061 left(ios); 10062 { 10063 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10064 std::string ex(str, iter.base()); 10065 assert(ex == "+1234567890.1************"); 10066 assert(ios.width() == 0); 10067 } 10068 ios.width(25); 10069 right(ios); 10070 { 10071 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10072 std::string ex(str, iter.base()); 10073 assert(ex == "************+1234567890.1"); 10074 assert(ios.width() == 0); 10075 } 10076 ios.width(25); 10077 internal(ios); 10078 { 10079 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10080 std::string ex(str, iter.base()); 10081 assert(ex == "+************1234567890.1"); 10082 assert(ios.width() == 0); 10083 } 10084 } 10085 ios.imbue(lg); 10086 { 10087 ios.width(0); 10088 { 10089 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10090 std::string ex(str, iter.base()); 10091 assert(ex == "+1_234_567_89_0;1"); 10092 assert(ios.width() == 0); 10093 } 10094 ios.width(25); 10095 left(ios); 10096 { 10097 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10098 std::string ex(str, iter.base()); 10099 assert(ex == "+1_234_567_89_0;1********"); 10100 assert(ios.width() == 0); 10101 } 10102 ios.width(25); 10103 right(ios); 10104 { 10105 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10106 std::string ex(str, iter.base()); 10107 assert(ex == "********+1_234_567_89_0;1"); 10108 assert(ios.width() == 0); 10109 } 10110 ios.width(25); 10111 internal(ios); 10112 { 10113 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10114 std::string ex(str, iter.base()); 10115 assert(ex == "+********1_234_567_89_0;1"); 10116 assert(ios.width() == 0); 10117 } 10118 } 10119 } 10120 } 10121 } 10122 } 10123 ios.precision(6); 10124 { 10125 nouppercase(ios); 10126 { 10127 noshowpos(ios); 10128 { 10129 noshowpoint(ios); 10130 { 10131 ios.imbue(lc); 10132 { 10133 ios.width(0); 10134 { 10135 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10136 std::string ex(str, iter.base()); 10137 assert(ex == "1234567890.125000"); 10138 assert(ios.width() == 0); 10139 } 10140 ios.width(25); 10141 left(ios); 10142 { 10143 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10144 std::string ex(str, iter.base()); 10145 assert(ex == "1234567890.125000********"); 10146 assert(ios.width() == 0); 10147 } 10148 ios.width(25); 10149 right(ios); 10150 { 10151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10152 std::string ex(str, iter.base()); 10153 assert(ex == "********1234567890.125000"); 10154 assert(ios.width() == 0); 10155 } 10156 ios.width(25); 10157 internal(ios); 10158 { 10159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10160 std::string ex(str, iter.base()); 10161 assert(ex == "********1234567890.125000"); 10162 assert(ios.width() == 0); 10163 } 10164 } 10165 ios.imbue(lg); 10166 { 10167 ios.width(0); 10168 { 10169 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10170 std::string ex(str, iter.base()); 10171 assert(ex == "1_234_567_89_0;125000"); 10172 assert(ios.width() == 0); 10173 } 10174 ios.width(25); 10175 left(ios); 10176 { 10177 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10178 std::string ex(str, iter.base()); 10179 assert(ex == "1_234_567_89_0;125000****"); 10180 assert(ios.width() == 0); 10181 } 10182 ios.width(25); 10183 right(ios); 10184 { 10185 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10186 std::string ex(str, iter.base()); 10187 assert(ex == "****1_234_567_89_0;125000"); 10188 assert(ios.width() == 0); 10189 } 10190 ios.width(25); 10191 internal(ios); 10192 { 10193 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10194 std::string ex(str, iter.base()); 10195 assert(ex == "****1_234_567_89_0;125000"); 10196 assert(ios.width() == 0); 10197 } 10198 } 10199 } 10200 showpoint(ios); 10201 { 10202 ios.imbue(lc); 10203 { 10204 ios.width(0); 10205 { 10206 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10207 std::string ex(str, iter.base()); 10208 assert(ex == "1234567890.125000"); 10209 assert(ios.width() == 0); 10210 } 10211 ios.width(25); 10212 left(ios); 10213 { 10214 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10215 std::string ex(str, iter.base()); 10216 assert(ex == "1234567890.125000********"); 10217 assert(ios.width() == 0); 10218 } 10219 ios.width(25); 10220 right(ios); 10221 { 10222 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10223 std::string ex(str, iter.base()); 10224 assert(ex == "********1234567890.125000"); 10225 assert(ios.width() == 0); 10226 } 10227 ios.width(25); 10228 internal(ios); 10229 { 10230 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10231 std::string ex(str, iter.base()); 10232 assert(ex == "********1234567890.125000"); 10233 assert(ios.width() == 0); 10234 } 10235 } 10236 ios.imbue(lg); 10237 { 10238 ios.width(0); 10239 { 10240 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10241 std::string ex(str, iter.base()); 10242 assert(ex == "1_234_567_89_0;125000"); 10243 assert(ios.width() == 0); 10244 } 10245 ios.width(25); 10246 left(ios); 10247 { 10248 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10249 std::string ex(str, iter.base()); 10250 assert(ex == "1_234_567_89_0;125000****"); 10251 assert(ios.width() == 0); 10252 } 10253 ios.width(25); 10254 right(ios); 10255 { 10256 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10257 std::string ex(str, iter.base()); 10258 assert(ex == "****1_234_567_89_0;125000"); 10259 assert(ios.width() == 0); 10260 } 10261 ios.width(25); 10262 internal(ios); 10263 { 10264 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10265 std::string ex(str, iter.base()); 10266 assert(ex == "****1_234_567_89_0;125000"); 10267 assert(ios.width() == 0); 10268 } 10269 } 10270 } 10271 } 10272 showpos(ios); 10273 { 10274 noshowpoint(ios); 10275 { 10276 ios.imbue(lc); 10277 { 10278 ios.width(0); 10279 { 10280 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10281 std::string ex(str, iter.base()); 10282 assert(ex == "+1234567890.125000"); 10283 assert(ios.width() == 0); 10284 } 10285 ios.width(25); 10286 left(ios); 10287 { 10288 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10289 std::string ex(str, iter.base()); 10290 assert(ex == "+1234567890.125000*******"); 10291 assert(ios.width() == 0); 10292 } 10293 ios.width(25); 10294 right(ios); 10295 { 10296 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10297 std::string ex(str, iter.base()); 10298 assert(ex == "*******+1234567890.125000"); 10299 assert(ios.width() == 0); 10300 } 10301 ios.width(25); 10302 internal(ios); 10303 { 10304 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10305 std::string ex(str, iter.base()); 10306 assert(ex == "+*******1234567890.125000"); 10307 assert(ios.width() == 0); 10308 } 10309 } 10310 ios.imbue(lg); 10311 { 10312 ios.width(0); 10313 { 10314 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10315 std::string ex(str, iter.base()); 10316 assert(ex == "+1_234_567_89_0;125000"); 10317 assert(ios.width() == 0); 10318 } 10319 ios.width(25); 10320 left(ios); 10321 { 10322 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10323 std::string ex(str, iter.base()); 10324 assert(ex == "+1_234_567_89_0;125000***"); 10325 assert(ios.width() == 0); 10326 } 10327 ios.width(25); 10328 right(ios); 10329 { 10330 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10331 std::string ex(str, iter.base()); 10332 assert(ex == "***+1_234_567_89_0;125000"); 10333 assert(ios.width() == 0); 10334 } 10335 ios.width(25); 10336 internal(ios); 10337 { 10338 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10339 std::string ex(str, iter.base()); 10340 assert(ex == "+***1_234_567_89_0;125000"); 10341 assert(ios.width() == 0); 10342 } 10343 } 10344 } 10345 showpoint(ios); 10346 { 10347 ios.imbue(lc); 10348 { 10349 ios.width(0); 10350 { 10351 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10352 std::string ex(str, iter.base()); 10353 assert(ex == "+1234567890.125000"); 10354 assert(ios.width() == 0); 10355 } 10356 ios.width(25); 10357 left(ios); 10358 { 10359 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10360 std::string ex(str, iter.base()); 10361 assert(ex == "+1234567890.125000*******"); 10362 assert(ios.width() == 0); 10363 } 10364 ios.width(25); 10365 right(ios); 10366 { 10367 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10368 std::string ex(str, iter.base()); 10369 assert(ex == "*******+1234567890.125000"); 10370 assert(ios.width() == 0); 10371 } 10372 ios.width(25); 10373 internal(ios); 10374 { 10375 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10376 std::string ex(str, iter.base()); 10377 assert(ex == "+*******1234567890.125000"); 10378 assert(ios.width() == 0); 10379 } 10380 } 10381 ios.imbue(lg); 10382 { 10383 ios.width(0); 10384 { 10385 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10386 std::string ex(str, iter.base()); 10387 assert(ex == "+1_234_567_89_0;125000"); 10388 assert(ios.width() == 0); 10389 } 10390 ios.width(25); 10391 left(ios); 10392 { 10393 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10394 std::string ex(str, iter.base()); 10395 assert(ex == "+1_234_567_89_0;125000***"); 10396 assert(ios.width() == 0); 10397 } 10398 ios.width(25); 10399 right(ios); 10400 { 10401 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10402 std::string ex(str, iter.base()); 10403 assert(ex == "***+1_234_567_89_0;125000"); 10404 assert(ios.width() == 0); 10405 } 10406 ios.width(25); 10407 internal(ios); 10408 { 10409 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10410 std::string ex(str, iter.base()); 10411 assert(ex == "+***1_234_567_89_0;125000"); 10412 assert(ios.width() == 0); 10413 } 10414 } 10415 } 10416 } 10417 } 10418 uppercase(ios); 10419 { 10420 noshowpos(ios); 10421 { 10422 noshowpoint(ios); 10423 { 10424 ios.imbue(lc); 10425 { 10426 ios.width(0); 10427 { 10428 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10429 std::string ex(str, iter.base()); 10430 assert(ex == "1234567890.125000"); 10431 assert(ios.width() == 0); 10432 } 10433 ios.width(25); 10434 left(ios); 10435 { 10436 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10437 std::string ex(str, iter.base()); 10438 assert(ex == "1234567890.125000********"); 10439 assert(ios.width() == 0); 10440 } 10441 ios.width(25); 10442 right(ios); 10443 { 10444 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10445 std::string ex(str, iter.base()); 10446 assert(ex == "********1234567890.125000"); 10447 assert(ios.width() == 0); 10448 } 10449 ios.width(25); 10450 internal(ios); 10451 { 10452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10453 std::string ex(str, iter.base()); 10454 assert(ex == "********1234567890.125000"); 10455 assert(ios.width() == 0); 10456 } 10457 } 10458 ios.imbue(lg); 10459 { 10460 ios.width(0); 10461 { 10462 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10463 std::string ex(str, iter.base()); 10464 assert(ex == "1_234_567_89_0;125000"); 10465 assert(ios.width() == 0); 10466 } 10467 ios.width(25); 10468 left(ios); 10469 { 10470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10471 std::string ex(str, iter.base()); 10472 assert(ex == "1_234_567_89_0;125000****"); 10473 assert(ios.width() == 0); 10474 } 10475 ios.width(25); 10476 right(ios); 10477 { 10478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10479 std::string ex(str, iter.base()); 10480 assert(ex == "****1_234_567_89_0;125000"); 10481 assert(ios.width() == 0); 10482 } 10483 ios.width(25); 10484 internal(ios); 10485 { 10486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10487 std::string ex(str, iter.base()); 10488 assert(ex == "****1_234_567_89_0;125000"); 10489 assert(ios.width() == 0); 10490 } 10491 } 10492 } 10493 showpoint(ios); 10494 { 10495 ios.imbue(lc); 10496 { 10497 ios.width(0); 10498 { 10499 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10500 std::string ex(str, iter.base()); 10501 assert(ex == "1234567890.125000"); 10502 assert(ios.width() == 0); 10503 } 10504 ios.width(25); 10505 left(ios); 10506 { 10507 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10508 std::string ex(str, iter.base()); 10509 assert(ex == "1234567890.125000********"); 10510 assert(ios.width() == 0); 10511 } 10512 ios.width(25); 10513 right(ios); 10514 { 10515 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10516 std::string ex(str, iter.base()); 10517 assert(ex == "********1234567890.125000"); 10518 assert(ios.width() == 0); 10519 } 10520 ios.width(25); 10521 internal(ios); 10522 { 10523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10524 std::string ex(str, iter.base()); 10525 assert(ex == "********1234567890.125000"); 10526 assert(ios.width() == 0); 10527 } 10528 } 10529 ios.imbue(lg); 10530 { 10531 ios.width(0); 10532 { 10533 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10534 std::string ex(str, iter.base()); 10535 assert(ex == "1_234_567_89_0;125000"); 10536 assert(ios.width() == 0); 10537 } 10538 ios.width(25); 10539 left(ios); 10540 { 10541 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10542 std::string ex(str, iter.base()); 10543 assert(ex == "1_234_567_89_0;125000****"); 10544 assert(ios.width() == 0); 10545 } 10546 ios.width(25); 10547 right(ios); 10548 { 10549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10550 std::string ex(str, iter.base()); 10551 assert(ex == "****1_234_567_89_0;125000"); 10552 assert(ios.width() == 0); 10553 } 10554 ios.width(25); 10555 internal(ios); 10556 { 10557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10558 std::string ex(str, iter.base()); 10559 assert(ex == "****1_234_567_89_0;125000"); 10560 assert(ios.width() == 0); 10561 } 10562 } 10563 } 10564 } 10565 showpos(ios); 10566 { 10567 noshowpoint(ios); 10568 { 10569 ios.imbue(lc); 10570 { 10571 ios.width(0); 10572 { 10573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10574 std::string ex(str, iter.base()); 10575 assert(ex == "+1234567890.125000"); 10576 assert(ios.width() == 0); 10577 } 10578 ios.width(25); 10579 left(ios); 10580 { 10581 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10582 std::string ex(str, iter.base()); 10583 assert(ex == "+1234567890.125000*******"); 10584 assert(ios.width() == 0); 10585 } 10586 ios.width(25); 10587 right(ios); 10588 { 10589 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10590 std::string ex(str, iter.base()); 10591 assert(ex == "*******+1234567890.125000"); 10592 assert(ios.width() == 0); 10593 } 10594 ios.width(25); 10595 internal(ios); 10596 { 10597 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10598 std::string ex(str, iter.base()); 10599 assert(ex == "+*******1234567890.125000"); 10600 assert(ios.width() == 0); 10601 } 10602 } 10603 ios.imbue(lg); 10604 { 10605 ios.width(0); 10606 { 10607 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10608 std::string ex(str, iter.base()); 10609 assert(ex == "+1_234_567_89_0;125000"); 10610 assert(ios.width() == 0); 10611 } 10612 ios.width(25); 10613 left(ios); 10614 { 10615 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10616 std::string ex(str, iter.base()); 10617 assert(ex == "+1_234_567_89_0;125000***"); 10618 assert(ios.width() == 0); 10619 } 10620 ios.width(25); 10621 right(ios); 10622 { 10623 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10624 std::string ex(str, iter.base()); 10625 assert(ex == "***+1_234_567_89_0;125000"); 10626 assert(ios.width() == 0); 10627 } 10628 ios.width(25); 10629 internal(ios); 10630 { 10631 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10632 std::string ex(str, iter.base()); 10633 assert(ex == "+***1_234_567_89_0;125000"); 10634 assert(ios.width() == 0); 10635 } 10636 } 10637 } 10638 showpoint(ios); 10639 { 10640 ios.imbue(lc); 10641 { 10642 ios.width(0); 10643 { 10644 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10645 std::string ex(str, iter.base()); 10646 assert(ex == "+1234567890.125000"); 10647 assert(ios.width() == 0); 10648 } 10649 ios.width(25); 10650 left(ios); 10651 { 10652 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10653 std::string ex(str, iter.base()); 10654 assert(ex == "+1234567890.125000*******"); 10655 assert(ios.width() == 0); 10656 } 10657 ios.width(25); 10658 right(ios); 10659 { 10660 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10661 std::string ex(str, iter.base()); 10662 assert(ex == "*******+1234567890.125000"); 10663 assert(ios.width() == 0); 10664 } 10665 ios.width(25); 10666 internal(ios); 10667 { 10668 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10669 std::string ex(str, iter.base()); 10670 assert(ex == "+*******1234567890.125000"); 10671 assert(ios.width() == 0); 10672 } 10673 } 10674 ios.imbue(lg); 10675 { 10676 ios.width(0); 10677 { 10678 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10679 std::string ex(str, iter.base()); 10680 assert(ex == "+1_234_567_89_0;125000"); 10681 assert(ios.width() == 0); 10682 } 10683 ios.width(25); 10684 left(ios); 10685 { 10686 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10687 std::string ex(str, iter.base()); 10688 assert(ex == "+1_234_567_89_0;125000***"); 10689 assert(ios.width() == 0); 10690 } 10691 ios.width(25); 10692 right(ios); 10693 { 10694 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10695 std::string ex(str, iter.base()); 10696 assert(ex == "***+1_234_567_89_0;125000"); 10697 assert(ios.width() == 0); 10698 } 10699 ios.width(25); 10700 internal(ios); 10701 { 10702 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10703 std::string ex(str, iter.base()); 10704 assert(ex == "+***1_234_567_89_0;125000"); 10705 assert(ios.width() == 0); 10706 } 10707 } 10708 } 10709 } 10710 } 10711 } 10712 ios.precision(16); 10713 {} 10714 ios.precision(60); 10715 {} 10716 } 10717 } 10718 } 10719 10720 void test5() 10721 { 10722 char str[200]; 10723 output_iterator<char*> iter; 10724 std::locale lc = std::locale::classic(); 10725 std::locale lg(lc, new my_numpunct); 10726 const my_facet f(1); 10727 { 10728 double v = -0.; 10729 std::ios ios(0); 10730 scientific(ios); 10731 // %e 10732 { 10733 ios.precision(0); 10734 { 10735 nouppercase(ios); 10736 { 10737 noshowpos(ios); 10738 { 10739 noshowpoint(ios); 10740 { 10741 ios.imbue(lc); 10742 { 10743 ios.width(0); 10744 { 10745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10746 std::string ex(str, iter.base()); 10747 assert(ex == "-0e+00"); 10748 assert(ios.width() == 0); 10749 } 10750 ios.width(25); 10751 left(ios); 10752 { 10753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10754 std::string ex(str, iter.base()); 10755 assert(ex == "-0e+00*******************"); 10756 assert(ios.width() == 0); 10757 } 10758 ios.width(25); 10759 right(ios); 10760 { 10761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10762 std::string ex(str, iter.base()); 10763 assert(ex == "*******************-0e+00"); 10764 assert(ios.width() == 0); 10765 } 10766 ios.width(25); 10767 internal(ios); 10768 { 10769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10770 std::string ex(str, iter.base()); 10771 assert(ex == "-*******************0e+00"); 10772 assert(ios.width() == 0); 10773 } 10774 } 10775 ios.imbue(lg); 10776 { 10777 ios.width(0); 10778 { 10779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10780 std::string ex(str, iter.base()); 10781 assert(ex == "-0e+00"); 10782 assert(ios.width() == 0); 10783 } 10784 ios.width(25); 10785 left(ios); 10786 { 10787 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10788 std::string ex(str, iter.base()); 10789 assert(ex == "-0e+00*******************"); 10790 assert(ios.width() == 0); 10791 } 10792 ios.width(25); 10793 right(ios); 10794 { 10795 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10796 std::string ex(str, iter.base()); 10797 assert(ex == "*******************-0e+00"); 10798 assert(ios.width() == 0); 10799 } 10800 ios.width(25); 10801 internal(ios); 10802 { 10803 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10804 std::string ex(str, iter.base()); 10805 assert(ex == "-*******************0e+00"); 10806 assert(ios.width() == 0); 10807 } 10808 } 10809 } 10810 showpoint(ios); 10811 { 10812 ios.imbue(lc); 10813 { 10814 ios.width(0); 10815 { 10816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10817 std::string ex(str, iter.base()); 10818 assert(ex == "-0.e+00"); 10819 assert(ios.width() == 0); 10820 } 10821 ios.width(25); 10822 left(ios); 10823 { 10824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10825 std::string ex(str, iter.base()); 10826 assert(ex == "-0.e+00******************"); 10827 assert(ios.width() == 0); 10828 } 10829 ios.width(25); 10830 right(ios); 10831 { 10832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10833 std::string ex(str, iter.base()); 10834 assert(ex == "******************-0.e+00"); 10835 assert(ios.width() == 0); 10836 } 10837 ios.width(25); 10838 internal(ios); 10839 { 10840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10841 std::string ex(str, iter.base()); 10842 assert(ex == "-******************0.e+00"); 10843 assert(ios.width() == 0); 10844 } 10845 } 10846 ios.imbue(lg); 10847 { 10848 ios.width(0); 10849 { 10850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10851 std::string ex(str, iter.base()); 10852 assert(ex == "-0;e+00"); 10853 assert(ios.width() == 0); 10854 } 10855 ios.width(25); 10856 left(ios); 10857 { 10858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10859 std::string ex(str, iter.base()); 10860 assert(ex == "-0;e+00******************"); 10861 assert(ios.width() == 0); 10862 } 10863 ios.width(25); 10864 right(ios); 10865 { 10866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10867 std::string ex(str, iter.base()); 10868 assert(ex == "******************-0;e+00"); 10869 assert(ios.width() == 0); 10870 } 10871 ios.width(25); 10872 internal(ios); 10873 { 10874 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10875 std::string ex(str, iter.base()); 10876 assert(ex == "-******************0;e+00"); 10877 assert(ios.width() == 0); 10878 } 10879 } 10880 } 10881 } 10882 showpos(ios); 10883 { 10884 noshowpoint(ios); 10885 { 10886 ios.imbue(lc); 10887 { 10888 ios.width(0); 10889 { 10890 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10891 std::string ex(str, iter.base()); 10892 assert(ex == "-0e+00"); 10893 assert(ios.width() == 0); 10894 } 10895 ios.width(25); 10896 left(ios); 10897 { 10898 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10899 std::string ex(str, iter.base()); 10900 assert(ex == "-0e+00*******************"); 10901 assert(ios.width() == 0); 10902 } 10903 ios.width(25); 10904 right(ios); 10905 { 10906 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10907 std::string ex(str, iter.base()); 10908 assert(ex == "*******************-0e+00"); 10909 assert(ios.width() == 0); 10910 } 10911 ios.width(25); 10912 internal(ios); 10913 { 10914 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10915 std::string ex(str, iter.base()); 10916 assert(ex == "-*******************0e+00"); 10917 assert(ios.width() == 0); 10918 } 10919 } 10920 ios.imbue(lg); 10921 { 10922 ios.width(0); 10923 { 10924 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10925 std::string ex(str, iter.base()); 10926 assert(ex == "-0e+00"); 10927 assert(ios.width() == 0); 10928 } 10929 ios.width(25); 10930 left(ios); 10931 { 10932 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10933 std::string ex(str, iter.base()); 10934 assert(ex == "-0e+00*******************"); 10935 assert(ios.width() == 0); 10936 } 10937 ios.width(25); 10938 right(ios); 10939 { 10940 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10941 std::string ex(str, iter.base()); 10942 assert(ex == "*******************-0e+00"); 10943 assert(ios.width() == 0); 10944 } 10945 ios.width(25); 10946 internal(ios); 10947 { 10948 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10949 std::string ex(str, iter.base()); 10950 assert(ex == "-*******************0e+00"); 10951 assert(ios.width() == 0); 10952 } 10953 } 10954 } 10955 showpoint(ios); 10956 { 10957 ios.imbue(lc); 10958 { 10959 ios.width(0); 10960 { 10961 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10962 std::string ex(str, iter.base()); 10963 assert(ex == "-0.e+00"); 10964 assert(ios.width() == 0); 10965 } 10966 ios.width(25); 10967 left(ios); 10968 { 10969 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10970 std::string ex(str, iter.base()); 10971 assert(ex == "-0.e+00******************"); 10972 assert(ios.width() == 0); 10973 } 10974 ios.width(25); 10975 right(ios); 10976 { 10977 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10978 std::string ex(str, iter.base()); 10979 assert(ex == "******************-0.e+00"); 10980 assert(ios.width() == 0); 10981 } 10982 ios.width(25); 10983 internal(ios); 10984 { 10985 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10986 std::string ex(str, iter.base()); 10987 assert(ex == "-******************0.e+00"); 10988 assert(ios.width() == 0); 10989 } 10990 } 10991 ios.imbue(lg); 10992 { 10993 ios.width(0); 10994 { 10995 iter = f.put(output_iterator<char*>(str), ios, '*', v); 10996 std::string ex(str, iter.base()); 10997 assert(ex == "-0;e+00"); 10998 assert(ios.width() == 0); 10999 } 11000 ios.width(25); 11001 left(ios); 11002 { 11003 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11004 std::string ex(str, iter.base()); 11005 assert(ex == "-0;e+00******************"); 11006 assert(ios.width() == 0); 11007 } 11008 ios.width(25); 11009 right(ios); 11010 { 11011 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11012 std::string ex(str, iter.base()); 11013 assert(ex == "******************-0;e+00"); 11014 assert(ios.width() == 0); 11015 } 11016 ios.width(25); 11017 internal(ios); 11018 { 11019 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11020 std::string ex(str, iter.base()); 11021 assert(ex == "-******************0;e+00"); 11022 assert(ios.width() == 0); 11023 } 11024 } 11025 } 11026 } 11027 } 11028 uppercase(ios); 11029 { 11030 noshowpos(ios); 11031 { 11032 noshowpoint(ios); 11033 { 11034 ios.imbue(lc); 11035 { 11036 ios.width(0); 11037 { 11038 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11039 std::string ex(str, iter.base()); 11040 assert(ex == "-0E+00"); 11041 assert(ios.width() == 0); 11042 } 11043 ios.width(25); 11044 left(ios); 11045 { 11046 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11047 std::string ex(str, iter.base()); 11048 assert(ex == "-0E+00*******************"); 11049 assert(ios.width() == 0); 11050 } 11051 ios.width(25); 11052 right(ios); 11053 { 11054 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11055 std::string ex(str, iter.base()); 11056 assert(ex == "*******************-0E+00"); 11057 assert(ios.width() == 0); 11058 } 11059 ios.width(25); 11060 internal(ios); 11061 { 11062 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11063 std::string ex(str, iter.base()); 11064 assert(ex == "-*******************0E+00"); 11065 assert(ios.width() == 0); 11066 } 11067 } 11068 ios.imbue(lg); 11069 { 11070 ios.width(0); 11071 { 11072 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11073 std::string ex(str, iter.base()); 11074 assert(ex == "-0E+00"); 11075 assert(ios.width() == 0); 11076 } 11077 ios.width(25); 11078 left(ios); 11079 { 11080 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11081 std::string ex(str, iter.base()); 11082 assert(ex == "-0E+00*******************"); 11083 assert(ios.width() == 0); 11084 } 11085 ios.width(25); 11086 right(ios); 11087 { 11088 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11089 std::string ex(str, iter.base()); 11090 assert(ex == "*******************-0E+00"); 11091 assert(ios.width() == 0); 11092 } 11093 ios.width(25); 11094 internal(ios); 11095 { 11096 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11097 std::string ex(str, iter.base()); 11098 assert(ex == "-*******************0E+00"); 11099 assert(ios.width() == 0); 11100 } 11101 } 11102 } 11103 showpoint(ios); 11104 { 11105 ios.imbue(lc); 11106 { 11107 ios.width(0); 11108 { 11109 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11110 std::string ex(str, iter.base()); 11111 assert(ex == "-0.E+00"); 11112 assert(ios.width() == 0); 11113 } 11114 ios.width(25); 11115 left(ios); 11116 { 11117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11118 std::string ex(str, iter.base()); 11119 assert(ex == "-0.E+00******************"); 11120 assert(ios.width() == 0); 11121 } 11122 ios.width(25); 11123 right(ios); 11124 { 11125 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11126 std::string ex(str, iter.base()); 11127 assert(ex == "******************-0.E+00"); 11128 assert(ios.width() == 0); 11129 } 11130 ios.width(25); 11131 internal(ios); 11132 { 11133 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11134 std::string ex(str, iter.base()); 11135 assert(ex == "-******************0.E+00"); 11136 assert(ios.width() == 0); 11137 } 11138 } 11139 ios.imbue(lg); 11140 { 11141 ios.width(0); 11142 { 11143 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11144 std::string ex(str, iter.base()); 11145 assert(ex == "-0;E+00"); 11146 assert(ios.width() == 0); 11147 } 11148 ios.width(25); 11149 left(ios); 11150 { 11151 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11152 std::string ex(str, iter.base()); 11153 assert(ex == "-0;E+00******************"); 11154 assert(ios.width() == 0); 11155 } 11156 ios.width(25); 11157 right(ios); 11158 { 11159 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11160 std::string ex(str, iter.base()); 11161 assert(ex == "******************-0;E+00"); 11162 assert(ios.width() == 0); 11163 } 11164 ios.width(25); 11165 internal(ios); 11166 { 11167 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11168 std::string ex(str, iter.base()); 11169 assert(ex == "-******************0;E+00"); 11170 assert(ios.width() == 0); 11171 } 11172 } 11173 } 11174 } 11175 showpos(ios); 11176 { 11177 noshowpoint(ios); 11178 { 11179 ios.imbue(lc); 11180 { 11181 ios.width(0); 11182 { 11183 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11184 std::string ex(str, iter.base()); 11185 assert(ex == "-0E+00"); 11186 assert(ios.width() == 0); 11187 } 11188 ios.width(25); 11189 left(ios); 11190 { 11191 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11192 std::string ex(str, iter.base()); 11193 assert(ex == "-0E+00*******************"); 11194 assert(ios.width() == 0); 11195 } 11196 ios.width(25); 11197 right(ios); 11198 { 11199 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11200 std::string ex(str, iter.base()); 11201 assert(ex == "*******************-0E+00"); 11202 assert(ios.width() == 0); 11203 } 11204 ios.width(25); 11205 internal(ios); 11206 { 11207 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11208 std::string ex(str, iter.base()); 11209 assert(ex == "-*******************0E+00"); 11210 assert(ios.width() == 0); 11211 } 11212 } 11213 ios.imbue(lg); 11214 { 11215 ios.width(0); 11216 { 11217 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11218 std::string ex(str, iter.base()); 11219 assert(ex == "-0E+00"); 11220 assert(ios.width() == 0); 11221 } 11222 ios.width(25); 11223 left(ios); 11224 { 11225 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11226 std::string ex(str, iter.base()); 11227 assert(ex == "-0E+00*******************"); 11228 assert(ios.width() == 0); 11229 } 11230 ios.width(25); 11231 right(ios); 11232 { 11233 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11234 std::string ex(str, iter.base()); 11235 assert(ex == "*******************-0E+00"); 11236 assert(ios.width() == 0); 11237 } 11238 ios.width(25); 11239 internal(ios); 11240 { 11241 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11242 std::string ex(str, iter.base()); 11243 assert(ex == "-*******************0E+00"); 11244 assert(ios.width() == 0); 11245 } 11246 } 11247 } 11248 showpoint(ios); 11249 { 11250 ios.imbue(lc); 11251 { 11252 ios.width(0); 11253 { 11254 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11255 std::string ex(str, iter.base()); 11256 assert(ex == "-0.E+00"); 11257 assert(ios.width() == 0); 11258 } 11259 ios.width(25); 11260 left(ios); 11261 { 11262 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11263 std::string ex(str, iter.base()); 11264 assert(ex == "-0.E+00******************"); 11265 assert(ios.width() == 0); 11266 } 11267 ios.width(25); 11268 right(ios); 11269 { 11270 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11271 std::string ex(str, iter.base()); 11272 assert(ex == "******************-0.E+00"); 11273 assert(ios.width() == 0); 11274 } 11275 ios.width(25); 11276 internal(ios); 11277 { 11278 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11279 std::string ex(str, iter.base()); 11280 assert(ex == "-******************0.E+00"); 11281 assert(ios.width() == 0); 11282 } 11283 } 11284 ios.imbue(lg); 11285 { 11286 ios.width(0); 11287 { 11288 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11289 std::string ex(str, iter.base()); 11290 assert(ex == "-0;E+00"); 11291 assert(ios.width() == 0); 11292 } 11293 ios.width(25); 11294 left(ios); 11295 { 11296 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11297 std::string ex(str, iter.base()); 11298 assert(ex == "-0;E+00******************"); 11299 assert(ios.width() == 0); 11300 } 11301 ios.width(25); 11302 right(ios); 11303 { 11304 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11305 std::string ex(str, iter.base()); 11306 assert(ex == "******************-0;E+00"); 11307 assert(ios.width() == 0); 11308 } 11309 ios.width(25); 11310 internal(ios); 11311 { 11312 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11313 std::string ex(str, iter.base()); 11314 assert(ex == "-******************0;E+00"); 11315 assert(ios.width() == 0); 11316 } 11317 } 11318 } 11319 } 11320 } 11321 } 11322 ios.precision(1); 11323 { 11324 nouppercase(ios); 11325 { 11326 noshowpos(ios); 11327 { 11328 noshowpoint(ios); 11329 { 11330 ios.imbue(lc); 11331 { 11332 ios.width(0); 11333 { 11334 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11335 std::string ex(str, iter.base()); 11336 assert(ex == "-0.0e+00"); 11337 assert(ios.width() == 0); 11338 } 11339 ios.width(25); 11340 left(ios); 11341 { 11342 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11343 std::string ex(str, iter.base()); 11344 assert(ex == "-0.0e+00*****************"); 11345 assert(ios.width() == 0); 11346 } 11347 ios.width(25); 11348 right(ios); 11349 { 11350 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11351 std::string ex(str, iter.base()); 11352 assert(ex == "*****************-0.0e+00"); 11353 assert(ios.width() == 0); 11354 } 11355 ios.width(25); 11356 internal(ios); 11357 { 11358 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11359 std::string ex(str, iter.base()); 11360 assert(ex == "-*****************0.0e+00"); 11361 assert(ios.width() == 0); 11362 } 11363 } 11364 ios.imbue(lg); 11365 { 11366 ios.width(0); 11367 { 11368 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11369 std::string ex(str, iter.base()); 11370 assert(ex == "-0;0e+00"); 11371 assert(ios.width() == 0); 11372 } 11373 ios.width(25); 11374 left(ios); 11375 { 11376 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11377 std::string ex(str, iter.base()); 11378 assert(ex == "-0;0e+00*****************"); 11379 assert(ios.width() == 0); 11380 } 11381 ios.width(25); 11382 right(ios); 11383 { 11384 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11385 std::string ex(str, iter.base()); 11386 assert(ex == "*****************-0;0e+00"); 11387 assert(ios.width() == 0); 11388 } 11389 ios.width(25); 11390 internal(ios); 11391 { 11392 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11393 std::string ex(str, iter.base()); 11394 assert(ex == "-*****************0;0e+00"); 11395 assert(ios.width() == 0); 11396 } 11397 } 11398 } 11399 showpoint(ios); 11400 { 11401 ios.imbue(lc); 11402 { 11403 ios.width(0); 11404 { 11405 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11406 std::string ex(str, iter.base()); 11407 assert(ex == "-0.0e+00"); 11408 assert(ios.width() == 0); 11409 } 11410 ios.width(25); 11411 left(ios); 11412 { 11413 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11414 std::string ex(str, iter.base()); 11415 assert(ex == "-0.0e+00*****************"); 11416 assert(ios.width() == 0); 11417 } 11418 ios.width(25); 11419 right(ios); 11420 { 11421 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11422 std::string ex(str, iter.base()); 11423 assert(ex == "*****************-0.0e+00"); 11424 assert(ios.width() == 0); 11425 } 11426 ios.width(25); 11427 internal(ios); 11428 { 11429 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11430 std::string ex(str, iter.base()); 11431 assert(ex == "-*****************0.0e+00"); 11432 assert(ios.width() == 0); 11433 } 11434 } 11435 ios.imbue(lg); 11436 { 11437 ios.width(0); 11438 { 11439 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11440 std::string ex(str, iter.base()); 11441 assert(ex == "-0;0e+00"); 11442 assert(ios.width() == 0); 11443 } 11444 ios.width(25); 11445 left(ios); 11446 { 11447 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11448 std::string ex(str, iter.base()); 11449 assert(ex == "-0;0e+00*****************"); 11450 assert(ios.width() == 0); 11451 } 11452 ios.width(25); 11453 right(ios); 11454 { 11455 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11456 std::string ex(str, iter.base()); 11457 assert(ex == "*****************-0;0e+00"); 11458 assert(ios.width() == 0); 11459 } 11460 ios.width(25); 11461 internal(ios); 11462 { 11463 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11464 std::string ex(str, iter.base()); 11465 assert(ex == "-*****************0;0e+00"); 11466 assert(ios.width() == 0); 11467 } 11468 } 11469 } 11470 } 11471 showpos(ios); 11472 { 11473 noshowpoint(ios); 11474 { 11475 ios.imbue(lc); 11476 { 11477 ios.width(0); 11478 { 11479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11480 std::string ex(str, iter.base()); 11481 assert(ex == "-0.0e+00"); 11482 assert(ios.width() == 0); 11483 } 11484 ios.width(25); 11485 left(ios); 11486 { 11487 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11488 std::string ex(str, iter.base()); 11489 assert(ex == "-0.0e+00*****************"); 11490 assert(ios.width() == 0); 11491 } 11492 ios.width(25); 11493 right(ios); 11494 { 11495 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11496 std::string ex(str, iter.base()); 11497 assert(ex == "*****************-0.0e+00"); 11498 assert(ios.width() == 0); 11499 } 11500 ios.width(25); 11501 internal(ios); 11502 { 11503 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11504 std::string ex(str, iter.base()); 11505 assert(ex == "-*****************0.0e+00"); 11506 assert(ios.width() == 0); 11507 } 11508 } 11509 ios.imbue(lg); 11510 { 11511 ios.width(0); 11512 { 11513 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11514 std::string ex(str, iter.base()); 11515 assert(ex == "-0;0e+00"); 11516 assert(ios.width() == 0); 11517 } 11518 ios.width(25); 11519 left(ios); 11520 { 11521 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11522 std::string ex(str, iter.base()); 11523 assert(ex == "-0;0e+00*****************"); 11524 assert(ios.width() == 0); 11525 } 11526 ios.width(25); 11527 right(ios); 11528 { 11529 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11530 std::string ex(str, iter.base()); 11531 assert(ex == "*****************-0;0e+00"); 11532 assert(ios.width() == 0); 11533 } 11534 ios.width(25); 11535 internal(ios); 11536 { 11537 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11538 std::string ex(str, iter.base()); 11539 assert(ex == "-*****************0;0e+00"); 11540 assert(ios.width() == 0); 11541 } 11542 } 11543 } 11544 showpoint(ios); 11545 { 11546 ios.imbue(lc); 11547 { 11548 ios.width(0); 11549 { 11550 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11551 std::string ex(str, iter.base()); 11552 assert(ex == "-0.0e+00"); 11553 assert(ios.width() == 0); 11554 } 11555 ios.width(25); 11556 left(ios); 11557 { 11558 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11559 std::string ex(str, iter.base()); 11560 assert(ex == "-0.0e+00*****************"); 11561 assert(ios.width() == 0); 11562 } 11563 ios.width(25); 11564 right(ios); 11565 { 11566 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11567 std::string ex(str, iter.base()); 11568 assert(ex == "*****************-0.0e+00"); 11569 assert(ios.width() == 0); 11570 } 11571 ios.width(25); 11572 internal(ios); 11573 { 11574 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11575 std::string ex(str, iter.base()); 11576 assert(ex == "-*****************0.0e+00"); 11577 assert(ios.width() == 0); 11578 } 11579 } 11580 ios.imbue(lg); 11581 { 11582 ios.width(0); 11583 { 11584 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11585 std::string ex(str, iter.base()); 11586 assert(ex == "-0;0e+00"); 11587 assert(ios.width() == 0); 11588 } 11589 ios.width(25); 11590 left(ios); 11591 { 11592 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11593 std::string ex(str, iter.base()); 11594 assert(ex == "-0;0e+00*****************"); 11595 assert(ios.width() == 0); 11596 } 11597 ios.width(25); 11598 right(ios); 11599 { 11600 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11601 std::string ex(str, iter.base()); 11602 assert(ex == "*****************-0;0e+00"); 11603 assert(ios.width() == 0); 11604 } 11605 ios.width(25); 11606 internal(ios); 11607 { 11608 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11609 std::string ex(str, iter.base()); 11610 assert(ex == "-*****************0;0e+00"); 11611 assert(ios.width() == 0); 11612 } 11613 } 11614 } 11615 } 11616 } 11617 uppercase(ios); 11618 { 11619 noshowpos(ios); 11620 { 11621 noshowpoint(ios); 11622 { 11623 ios.imbue(lc); 11624 { 11625 ios.width(0); 11626 { 11627 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11628 std::string ex(str, iter.base()); 11629 assert(ex == "-0.0E+00"); 11630 assert(ios.width() == 0); 11631 } 11632 ios.width(25); 11633 left(ios); 11634 { 11635 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11636 std::string ex(str, iter.base()); 11637 assert(ex == "-0.0E+00*****************"); 11638 assert(ios.width() == 0); 11639 } 11640 ios.width(25); 11641 right(ios); 11642 { 11643 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11644 std::string ex(str, iter.base()); 11645 assert(ex == "*****************-0.0E+00"); 11646 assert(ios.width() == 0); 11647 } 11648 ios.width(25); 11649 internal(ios); 11650 { 11651 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11652 std::string ex(str, iter.base()); 11653 assert(ex == "-*****************0.0E+00"); 11654 assert(ios.width() == 0); 11655 } 11656 } 11657 ios.imbue(lg); 11658 { 11659 ios.width(0); 11660 { 11661 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11662 std::string ex(str, iter.base()); 11663 assert(ex == "-0;0E+00"); 11664 assert(ios.width() == 0); 11665 } 11666 ios.width(25); 11667 left(ios); 11668 { 11669 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11670 std::string ex(str, iter.base()); 11671 assert(ex == "-0;0E+00*****************"); 11672 assert(ios.width() == 0); 11673 } 11674 ios.width(25); 11675 right(ios); 11676 { 11677 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11678 std::string ex(str, iter.base()); 11679 assert(ex == "*****************-0;0E+00"); 11680 assert(ios.width() == 0); 11681 } 11682 ios.width(25); 11683 internal(ios); 11684 { 11685 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11686 std::string ex(str, iter.base()); 11687 assert(ex == "-*****************0;0E+00"); 11688 assert(ios.width() == 0); 11689 } 11690 } 11691 } 11692 showpoint(ios); 11693 { 11694 ios.imbue(lc); 11695 { 11696 ios.width(0); 11697 { 11698 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11699 std::string ex(str, iter.base()); 11700 assert(ex == "-0.0E+00"); 11701 assert(ios.width() == 0); 11702 } 11703 ios.width(25); 11704 left(ios); 11705 { 11706 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11707 std::string ex(str, iter.base()); 11708 assert(ex == "-0.0E+00*****************"); 11709 assert(ios.width() == 0); 11710 } 11711 ios.width(25); 11712 right(ios); 11713 { 11714 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11715 std::string ex(str, iter.base()); 11716 assert(ex == "*****************-0.0E+00"); 11717 assert(ios.width() == 0); 11718 } 11719 ios.width(25); 11720 internal(ios); 11721 { 11722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11723 std::string ex(str, iter.base()); 11724 assert(ex == "-*****************0.0E+00"); 11725 assert(ios.width() == 0); 11726 } 11727 } 11728 ios.imbue(lg); 11729 { 11730 ios.width(0); 11731 { 11732 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11733 std::string ex(str, iter.base()); 11734 assert(ex == "-0;0E+00"); 11735 assert(ios.width() == 0); 11736 } 11737 ios.width(25); 11738 left(ios); 11739 { 11740 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11741 std::string ex(str, iter.base()); 11742 assert(ex == "-0;0E+00*****************"); 11743 assert(ios.width() == 0); 11744 } 11745 ios.width(25); 11746 right(ios); 11747 { 11748 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11749 std::string ex(str, iter.base()); 11750 assert(ex == "*****************-0;0E+00"); 11751 assert(ios.width() == 0); 11752 } 11753 ios.width(25); 11754 internal(ios); 11755 { 11756 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11757 std::string ex(str, iter.base()); 11758 assert(ex == "-*****************0;0E+00"); 11759 assert(ios.width() == 0); 11760 } 11761 } 11762 } 11763 } 11764 showpos(ios); 11765 { 11766 noshowpoint(ios); 11767 { 11768 ios.imbue(lc); 11769 { 11770 ios.width(0); 11771 { 11772 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11773 std::string ex(str, iter.base()); 11774 assert(ex == "-0.0E+00"); 11775 assert(ios.width() == 0); 11776 } 11777 ios.width(25); 11778 left(ios); 11779 { 11780 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11781 std::string ex(str, iter.base()); 11782 assert(ex == "-0.0E+00*****************"); 11783 assert(ios.width() == 0); 11784 } 11785 ios.width(25); 11786 right(ios); 11787 { 11788 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11789 std::string ex(str, iter.base()); 11790 assert(ex == "*****************-0.0E+00"); 11791 assert(ios.width() == 0); 11792 } 11793 ios.width(25); 11794 internal(ios); 11795 { 11796 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11797 std::string ex(str, iter.base()); 11798 assert(ex == "-*****************0.0E+00"); 11799 assert(ios.width() == 0); 11800 } 11801 } 11802 ios.imbue(lg); 11803 { 11804 ios.width(0); 11805 { 11806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11807 std::string ex(str, iter.base()); 11808 assert(ex == "-0;0E+00"); 11809 assert(ios.width() == 0); 11810 } 11811 ios.width(25); 11812 left(ios); 11813 { 11814 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11815 std::string ex(str, iter.base()); 11816 assert(ex == "-0;0E+00*****************"); 11817 assert(ios.width() == 0); 11818 } 11819 ios.width(25); 11820 right(ios); 11821 { 11822 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11823 std::string ex(str, iter.base()); 11824 assert(ex == "*****************-0;0E+00"); 11825 assert(ios.width() == 0); 11826 } 11827 ios.width(25); 11828 internal(ios); 11829 { 11830 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11831 std::string ex(str, iter.base()); 11832 assert(ex == "-*****************0;0E+00"); 11833 assert(ios.width() == 0); 11834 } 11835 } 11836 } 11837 showpoint(ios); 11838 { 11839 ios.imbue(lc); 11840 { 11841 ios.width(0); 11842 { 11843 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11844 std::string ex(str, iter.base()); 11845 assert(ex == "-0.0E+00"); 11846 assert(ios.width() == 0); 11847 } 11848 ios.width(25); 11849 left(ios); 11850 { 11851 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11852 std::string ex(str, iter.base()); 11853 assert(ex == "-0.0E+00*****************"); 11854 assert(ios.width() == 0); 11855 } 11856 ios.width(25); 11857 right(ios); 11858 { 11859 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11860 std::string ex(str, iter.base()); 11861 assert(ex == "*****************-0.0E+00"); 11862 assert(ios.width() == 0); 11863 } 11864 ios.width(25); 11865 internal(ios); 11866 { 11867 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11868 std::string ex(str, iter.base()); 11869 assert(ex == "-*****************0.0E+00"); 11870 assert(ios.width() == 0); 11871 } 11872 } 11873 ios.imbue(lg); 11874 { 11875 ios.width(0); 11876 { 11877 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11878 std::string ex(str, iter.base()); 11879 assert(ex == "-0;0E+00"); 11880 assert(ios.width() == 0); 11881 } 11882 ios.width(25); 11883 left(ios); 11884 { 11885 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11886 std::string ex(str, iter.base()); 11887 assert(ex == "-0;0E+00*****************"); 11888 assert(ios.width() == 0); 11889 } 11890 ios.width(25); 11891 right(ios); 11892 { 11893 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11894 std::string ex(str, iter.base()); 11895 assert(ex == "*****************-0;0E+00"); 11896 assert(ios.width() == 0); 11897 } 11898 ios.width(25); 11899 internal(ios); 11900 { 11901 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11902 std::string ex(str, iter.base()); 11903 assert(ex == "-*****************0;0E+00"); 11904 assert(ios.width() == 0); 11905 } 11906 } 11907 } 11908 } 11909 } 11910 } 11911 ios.precision(6); 11912 { 11913 nouppercase(ios); 11914 { 11915 noshowpos(ios); 11916 { 11917 noshowpoint(ios); 11918 { 11919 ios.imbue(lc); 11920 { 11921 ios.width(0); 11922 { 11923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11924 std::string ex(str, iter.base()); 11925 assert(ex == "-0.000000e+00"); 11926 assert(ios.width() == 0); 11927 } 11928 ios.width(25); 11929 left(ios); 11930 { 11931 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11932 std::string ex(str, iter.base()); 11933 assert(ex == "-0.000000e+00************"); 11934 assert(ios.width() == 0); 11935 } 11936 ios.width(25); 11937 right(ios); 11938 { 11939 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11940 std::string ex(str, iter.base()); 11941 assert(ex == "************-0.000000e+00"); 11942 assert(ios.width() == 0); 11943 } 11944 ios.width(25); 11945 internal(ios); 11946 { 11947 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11948 std::string ex(str, iter.base()); 11949 assert(ex == "-************0.000000e+00"); 11950 assert(ios.width() == 0); 11951 } 11952 } 11953 ios.imbue(lg); 11954 { 11955 ios.width(0); 11956 { 11957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11958 std::string ex(str, iter.base()); 11959 assert(ex == "-0;000000e+00"); 11960 assert(ios.width() == 0); 11961 } 11962 ios.width(25); 11963 left(ios); 11964 { 11965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11966 std::string ex(str, iter.base()); 11967 assert(ex == "-0;000000e+00************"); 11968 assert(ios.width() == 0); 11969 } 11970 ios.width(25); 11971 right(ios); 11972 { 11973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11974 std::string ex(str, iter.base()); 11975 assert(ex == "************-0;000000e+00"); 11976 assert(ios.width() == 0); 11977 } 11978 ios.width(25); 11979 internal(ios); 11980 { 11981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11982 std::string ex(str, iter.base()); 11983 assert(ex == "-************0;000000e+00"); 11984 assert(ios.width() == 0); 11985 } 11986 } 11987 } 11988 showpoint(ios); 11989 { 11990 ios.imbue(lc); 11991 { 11992 ios.width(0); 11993 { 11994 iter = f.put(output_iterator<char*>(str), ios, '*', v); 11995 std::string ex(str, iter.base()); 11996 assert(ex == "-0.000000e+00"); 11997 assert(ios.width() == 0); 11998 } 11999 ios.width(25); 12000 left(ios); 12001 { 12002 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12003 std::string ex(str, iter.base()); 12004 assert(ex == "-0.000000e+00************"); 12005 assert(ios.width() == 0); 12006 } 12007 ios.width(25); 12008 right(ios); 12009 { 12010 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12011 std::string ex(str, iter.base()); 12012 assert(ex == "************-0.000000e+00"); 12013 assert(ios.width() == 0); 12014 } 12015 ios.width(25); 12016 internal(ios); 12017 { 12018 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12019 std::string ex(str, iter.base()); 12020 assert(ex == "-************0.000000e+00"); 12021 assert(ios.width() == 0); 12022 } 12023 } 12024 ios.imbue(lg); 12025 { 12026 ios.width(0); 12027 { 12028 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12029 std::string ex(str, iter.base()); 12030 assert(ex == "-0;000000e+00"); 12031 assert(ios.width() == 0); 12032 } 12033 ios.width(25); 12034 left(ios); 12035 { 12036 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12037 std::string ex(str, iter.base()); 12038 assert(ex == "-0;000000e+00************"); 12039 assert(ios.width() == 0); 12040 } 12041 ios.width(25); 12042 right(ios); 12043 { 12044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12045 std::string ex(str, iter.base()); 12046 assert(ex == "************-0;000000e+00"); 12047 assert(ios.width() == 0); 12048 } 12049 ios.width(25); 12050 internal(ios); 12051 { 12052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12053 std::string ex(str, iter.base()); 12054 assert(ex == "-************0;000000e+00"); 12055 assert(ios.width() == 0); 12056 } 12057 } 12058 } 12059 } 12060 showpos(ios); 12061 { 12062 noshowpoint(ios); 12063 { 12064 ios.imbue(lc); 12065 { 12066 ios.width(0); 12067 { 12068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12069 std::string ex(str, iter.base()); 12070 assert(ex == "-0.000000e+00"); 12071 assert(ios.width() == 0); 12072 } 12073 ios.width(25); 12074 left(ios); 12075 { 12076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12077 std::string ex(str, iter.base()); 12078 assert(ex == "-0.000000e+00************"); 12079 assert(ios.width() == 0); 12080 } 12081 ios.width(25); 12082 right(ios); 12083 { 12084 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12085 std::string ex(str, iter.base()); 12086 assert(ex == "************-0.000000e+00"); 12087 assert(ios.width() == 0); 12088 } 12089 ios.width(25); 12090 internal(ios); 12091 { 12092 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12093 std::string ex(str, iter.base()); 12094 assert(ex == "-************0.000000e+00"); 12095 assert(ios.width() == 0); 12096 } 12097 } 12098 ios.imbue(lg); 12099 { 12100 ios.width(0); 12101 { 12102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12103 std::string ex(str, iter.base()); 12104 assert(ex == "-0;000000e+00"); 12105 assert(ios.width() == 0); 12106 } 12107 ios.width(25); 12108 left(ios); 12109 { 12110 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12111 std::string ex(str, iter.base()); 12112 assert(ex == "-0;000000e+00************"); 12113 assert(ios.width() == 0); 12114 } 12115 ios.width(25); 12116 right(ios); 12117 { 12118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12119 std::string ex(str, iter.base()); 12120 assert(ex == "************-0;000000e+00"); 12121 assert(ios.width() == 0); 12122 } 12123 ios.width(25); 12124 internal(ios); 12125 { 12126 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12127 std::string ex(str, iter.base()); 12128 assert(ex == "-************0;000000e+00"); 12129 assert(ios.width() == 0); 12130 } 12131 } 12132 } 12133 showpoint(ios); 12134 { 12135 ios.imbue(lc); 12136 { 12137 ios.width(0); 12138 { 12139 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12140 std::string ex(str, iter.base()); 12141 assert(ex == "-0.000000e+00"); 12142 assert(ios.width() == 0); 12143 } 12144 ios.width(25); 12145 left(ios); 12146 { 12147 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12148 std::string ex(str, iter.base()); 12149 assert(ex == "-0.000000e+00************"); 12150 assert(ios.width() == 0); 12151 } 12152 ios.width(25); 12153 right(ios); 12154 { 12155 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12156 std::string ex(str, iter.base()); 12157 assert(ex == "************-0.000000e+00"); 12158 assert(ios.width() == 0); 12159 } 12160 ios.width(25); 12161 internal(ios); 12162 { 12163 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12164 std::string ex(str, iter.base()); 12165 assert(ex == "-************0.000000e+00"); 12166 assert(ios.width() == 0); 12167 } 12168 } 12169 ios.imbue(lg); 12170 { 12171 ios.width(0); 12172 { 12173 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12174 std::string ex(str, iter.base()); 12175 assert(ex == "-0;000000e+00"); 12176 assert(ios.width() == 0); 12177 } 12178 ios.width(25); 12179 left(ios); 12180 { 12181 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12182 std::string ex(str, iter.base()); 12183 assert(ex == "-0;000000e+00************"); 12184 assert(ios.width() == 0); 12185 } 12186 ios.width(25); 12187 right(ios); 12188 { 12189 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12190 std::string ex(str, iter.base()); 12191 assert(ex == "************-0;000000e+00"); 12192 assert(ios.width() == 0); 12193 } 12194 ios.width(25); 12195 internal(ios); 12196 { 12197 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12198 std::string ex(str, iter.base()); 12199 assert(ex == "-************0;000000e+00"); 12200 assert(ios.width() == 0); 12201 } 12202 } 12203 } 12204 } 12205 } 12206 uppercase(ios); 12207 { 12208 noshowpos(ios); 12209 { 12210 noshowpoint(ios); 12211 { 12212 ios.imbue(lc); 12213 { 12214 ios.width(0); 12215 { 12216 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12217 std::string ex(str, iter.base()); 12218 assert(ex == "-0.000000E+00"); 12219 assert(ios.width() == 0); 12220 } 12221 ios.width(25); 12222 left(ios); 12223 { 12224 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12225 std::string ex(str, iter.base()); 12226 assert(ex == "-0.000000E+00************"); 12227 assert(ios.width() == 0); 12228 } 12229 ios.width(25); 12230 right(ios); 12231 { 12232 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12233 std::string ex(str, iter.base()); 12234 assert(ex == "************-0.000000E+00"); 12235 assert(ios.width() == 0); 12236 } 12237 ios.width(25); 12238 internal(ios); 12239 { 12240 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12241 std::string ex(str, iter.base()); 12242 assert(ex == "-************0.000000E+00"); 12243 assert(ios.width() == 0); 12244 } 12245 } 12246 ios.imbue(lg); 12247 { 12248 ios.width(0); 12249 { 12250 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12251 std::string ex(str, iter.base()); 12252 assert(ex == "-0;000000E+00"); 12253 assert(ios.width() == 0); 12254 } 12255 ios.width(25); 12256 left(ios); 12257 { 12258 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12259 std::string ex(str, iter.base()); 12260 assert(ex == "-0;000000E+00************"); 12261 assert(ios.width() == 0); 12262 } 12263 ios.width(25); 12264 right(ios); 12265 { 12266 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12267 std::string ex(str, iter.base()); 12268 assert(ex == "************-0;000000E+00"); 12269 assert(ios.width() == 0); 12270 } 12271 ios.width(25); 12272 internal(ios); 12273 { 12274 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12275 std::string ex(str, iter.base()); 12276 assert(ex == "-************0;000000E+00"); 12277 assert(ios.width() == 0); 12278 } 12279 } 12280 } 12281 showpoint(ios); 12282 { 12283 ios.imbue(lc); 12284 { 12285 ios.width(0); 12286 { 12287 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12288 std::string ex(str, iter.base()); 12289 assert(ex == "-0.000000E+00"); 12290 assert(ios.width() == 0); 12291 } 12292 ios.width(25); 12293 left(ios); 12294 { 12295 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12296 std::string ex(str, iter.base()); 12297 assert(ex == "-0.000000E+00************"); 12298 assert(ios.width() == 0); 12299 } 12300 ios.width(25); 12301 right(ios); 12302 { 12303 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12304 std::string ex(str, iter.base()); 12305 assert(ex == "************-0.000000E+00"); 12306 assert(ios.width() == 0); 12307 } 12308 ios.width(25); 12309 internal(ios); 12310 { 12311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12312 std::string ex(str, iter.base()); 12313 assert(ex == "-************0.000000E+00"); 12314 assert(ios.width() == 0); 12315 } 12316 } 12317 ios.imbue(lg); 12318 { 12319 ios.width(0); 12320 { 12321 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12322 std::string ex(str, iter.base()); 12323 assert(ex == "-0;000000E+00"); 12324 assert(ios.width() == 0); 12325 } 12326 ios.width(25); 12327 left(ios); 12328 { 12329 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12330 std::string ex(str, iter.base()); 12331 assert(ex == "-0;000000E+00************"); 12332 assert(ios.width() == 0); 12333 } 12334 ios.width(25); 12335 right(ios); 12336 { 12337 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12338 std::string ex(str, iter.base()); 12339 assert(ex == "************-0;000000E+00"); 12340 assert(ios.width() == 0); 12341 } 12342 ios.width(25); 12343 internal(ios); 12344 { 12345 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12346 std::string ex(str, iter.base()); 12347 assert(ex == "-************0;000000E+00"); 12348 assert(ios.width() == 0); 12349 } 12350 } 12351 } 12352 } 12353 showpos(ios); 12354 { 12355 noshowpoint(ios); 12356 { 12357 ios.imbue(lc); 12358 { 12359 ios.width(0); 12360 { 12361 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12362 std::string ex(str, iter.base()); 12363 assert(ex == "-0.000000E+00"); 12364 assert(ios.width() == 0); 12365 } 12366 ios.width(25); 12367 left(ios); 12368 { 12369 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12370 std::string ex(str, iter.base()); 12371 assert(ex == "-0.000000E+00************"); 12372 assert(ios.width() == 0); 12373 } 12374 ios.width(25); 12375 right(ios); 12376 { 12377 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12378 std::string ex(str, iter.base()); 12379 assert(ex == "************-0.000000E+00"); 12380 assert(ios.width() == 0); 12381 } 12382 ios.width(25); 12383 internal(ios); 12384 { 12385 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12386 std::string ex(str, iter.base()); 12387 assert(ex == "-************0.000000E+00"); 12388 assert(ios.width() == 0); 12389 } 12390 } 12391 ios.imbue(lg); 12392 { 12393 ios.width(0); 12394 { 12395 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12396 std::string ex(str, iter.base()); 12397 assert(ex == "-0;000000E+00"); 12398 assert(ios.width() == 0); 12399 } 12400 ios.width(25); 12401 left(ios); 12402 { 12403 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12404 std::string ex(str, iter.base()); 12405 assert(ex == "-0;000000E+00************"); 12406 assert(ios.width() == 0); 12407 } 12408 ios.width(25); 12409 right(ios); 12410 { 12411 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12412 std::string ex(str, iter.base()); 12413 assert(ex == "************-0;000000E+00"); 12414 assert(ios.width() == 0); 12415 } 12416 ios.width(25); 12417 internal(ios); 12418 { 12419 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12420 std::string ex(str, iter.base()); 12421 assert(ex == "-************0;000000E+00"); 12422 assert(ios.width() == 0); 12423 } 12424 } 12425 } 12426 showpoint(ios); 12427 { 12428 ios.imbue(lc); 12429 { 12430 ios.width(0); 12431 { 12432 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12433 std::string ex(str, iter.base()); 12434 assert(ex == "-0.000000E+00"); 12435 assert(ios.width() == 0); 12436 } 12437 ios.width(25); 12438 left(ios); 12439 { 12440 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12441 std::string ex(str, iter.base()); 12442 assert(ex == "-0.000000E+00************"); 12443 assert(ios.width() == 0); 12444 } 12445 ios.width(25); 12446 right(ios); 12447 { 12448 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12449 std::string ex(str, iter.base()); 12450 assert(ex == "************-0.000000E+00"); 12451 assert(ios.width() == 0); 12452 } 12453 ios.width(25); 12454 internal(ios); 12455 { 12456 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12457 std::string ex(str, iter.base()); 12458 assert(ex == "-************0.000000E+00"); 12459 assert(ios.width() == 0); 12460 } 12461 } 12462 ios.imbue(lg); 12463 { 12464 ios.width(0); 12465 { 12466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12467 std::string ex(str, iter.base()); 12468 assert(ex == "-0;000000E+00"); 12469 assert(ios.width() == 0); 12470 } 12471 ios.width(25); 12472 left(ios); 12473 { 12474 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12475 std::string ex(str, iter.base()); 12476 assert(ex == "-0;000000E+00************"); 12477 assert(ios.width() == 0); 12478 } 12479 ios.width(25); 12480 right(ios); 12481 { 12482 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12483 std::string ex(str, iter.base()); 12484 assert(ex == "************-0;000000E+00"); 12485 assert(ios.width() == 0); 12486 } 12487 ios.width(25); 12488 internal(ios); 12489 { 12490 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12491 std::string ex(str, iter.base()); 12492 assert(ex == "-************0;000000E+00"); 12493 assert(ios.width() == 0); 12494 } 12495 } 12496 } 12497 } 12498 } 12499 } 12500 ios.precision(16); 12501 { 12502 } 12503 ios.precision(60); 12504 { 12505 } 12506 } 12507 } 12508 } 12509 12510 void test6() 12511 { 12512 char str[200]; 12513 output_iterator<char*> iter; 12514 std::locale lc = std::locale::classic(); 12515 std::locale lg(lc, new my_numpunct); 12516 const my_facet f(1); 12517 { 12518 double v = 1234567890.125; 12519 std::ios ios(0); 12520 scientific(ios); 12521 // %e 12522 { 12523 ios.precision(0); 12524 { 12525 nouppercase(ios); 12526 { 12527 noshowpos(ios); 12528 { 12529 noshowpoint(ios); 12530 { 12531 ios.imbue(lc); 12532 { 12533 ios.width(0); 12534 { 12535 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12536 std::string ex(str, iter.base()); 12537 assert(ex == "1e+09"); 12538 assert(ios.width() == 0); 12539 } 12540 ios.width(25); 12541 left(ios); 12542 { 12543 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12544 std::string ex(str, iter.base()); 12545 assert(ex == "1e+09********************"); 12546 assert(ios.width() == 0); 12547 } 12548 ios.width(25); 12549 right(ios); 12550 { 12551 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12552 std::string ex(str, iter.base()); 12553 assert(ex == "********************1e+09"); 12554 assert(ios.width() == 0); 12555 } 12556 ios.width(25); 12557 internal(ios); 12558 { 12559 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12560 std::string ex(str, iter.base()); 12561 assert(ex == "********************1e+09"); 12562 assert(ios.width() == 0); 12563 } 12564 } 12565 ios.imbue(lg); 12566 { 12567 ios.width(0); 12568 { 12569 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12570 std::string ex(str, iter.base()); 12571 assert(ex == "1e+09"); 12572 assert(ios.width() == 0); 12573 } 12574 ios.width(25); 12575 left(ios); 12576 { 12577 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12578 std::string ex(str, iter.base()); 12579 assert(ex == "1e+09********************"); 12580 assert(ios.width() == 0); 12581 } 12582 ios.width(25); 12583 right(ios); 12584 { 12585 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12586 std::string ex(str, iter.base()); 12587 assert(ex == "********************1e+09"); 12588 assert(ios.width() == 0); 12589 } 12590 ios.width(25); 12591 internal(ios); 12592 { 12593 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12594 std::string ex(str, iter.base()); 12595 assert(ex == "********************1e+09"); 12596 assert(ios.width() == 0); 12597 } 12598 } 12599 } 12600 showpoint(ios); 12601 { 12602 ios.imbue(lc); 12603 { 12604 ios.width(0); 12605 { 12606 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12607 std::string ex(str, iter.base()); 12608 assert(ex == "1.e+09"); 12609 assert(ios.width() == 0); 12610 } 12611 ios.width(25); 12612 left(ios); 12613 { 12614 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12615 std::string ex(str, iter.base()); 12616 assert(ex == "1.e+09*******************"); 12617 assert(ios.width() == 0); 12618 } 12619 ios.width(25); 12620 right(ios); 12621 { 12622 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12623 std::string ex(str, iter.base()); 12624 assert(ex == "*******************1.e+09"); 12625 assert(ios.width() == 0); 12626 } 12627 ios.width(25); 12628 internal(ios); 12629 { 12630 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12631 std::string ex(str, iter.base()); 12632 assert(ex == "*******************1.e+09"); 12633 assert(ios.width() == 0); 12634 } 12635 } 12636 ios.imbue(lg); 12637 { 12638 ios.width(0); 12639 { 12640 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12641 std::string ex(str, iter.base()); 12642 assert(ex == "1;e+09"); 12643 assert(ios.width() == 0); 12644 } 12645 ios.width(25); 12646 left(ios); 12647 { 12648 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12649 std::string ex(str, iter.base()); 12650 assert(ex == "1;e+09*******************"); 12651 assert(ios.width() == 0); 12652 } 12653 ios.width(25); 12654 right(ios); 12655 { 12656 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12657 std::string ex(str, iter.base()); 12658 assert(ex == "*******************1;e+09"); 12659 assert(ios.width() == 0); 12660 } 12661 ios.width(25); 12662 internal(ios); 12663 { 12664 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12665 std::string ex(str, iter.base()); 12666 assert(ex == "*******************1;e+09"); 12667 assert(ios.width() == 0); 12668 } 12669 } 12670 } 12671 } 12672 showpos(ios); 12673 { 12674 noshowpoint(ios); 12675 { 12676 ios.imbue(lc); 12677 { 12678 ios.width(0); 12679 { 12680 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12681 std::string ex(str, iter.base()); 12682 assert(ex == "+1e+09"); 12683 assert(ios.width() == 0); 12684 } 12685 ios.width(25); 12686 left(ios); 12687 { 12688 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12689 std::string ex(str, iter.base()); 12690 assert(ex == "+1e+09*******************"); 12691 assert(ios.width() == 0); 12692 } 12693 ios.width(25); 12694 right(ios); 12695 { 12696 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12697 std::string ex(str, iter.base()); 12698 assert(ex == "*******************+1e+09"); 12699 assert(ios.width() == 0); 12700 } 12701 ios.width(25); 12702 internal(ios); 12703 { 12704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12705 std::string ex(str, iter.base()); 12706 assert(ex == "+*******************1e+09"); 12707 assert(ios.width() == 0); 12708 } 12709 } 12710 ios.imbue(lg); 12711 { 12712 ios.width(0); 12713 { 12714 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12715 std::string ex(str, iter.base()); 12716 assert(ex == "+1e+09"); 12717 assert(ios.width() == 0); 12718 } 12719 ios.width(25); 12720 left(ios); 12721 { 12722 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12723 std::string ex(str, iter.base()); 12724 assert(ex == "+1e+09*******************"); 12725 assert(ios.width() == 0); 12726 } 12727 ios.width(25); 12728 right(ios); 12729 { 12730 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12731 std::string ex(str, iter.base()); 12732 assert(ex == "*******************+1e+09"); 12733 assert(ios.width() == 0); 12734 } 12735 ios.width(25); 12736 internal(ios); 12737 { 12738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12739 std::string ex(str, iter.base()); 12740 assert(ex == "+*******************1e+09"); 12741 assert(ios.width() == 0); 12742 } 12743 } 12744 } 12745 showpoint(ios); 12746 { 12747 ios.imbue(lc); 12748 { 12749 ios.width(0); 12750 { 12751 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12752 std::string ex(str, iter.base()); 12753 assert(ex == "+1.e+09"); 12754 assert(ios.width() == 0); 12755 } 12756 ios.width(25); 12757 left(ios); 12758 { 12759 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12760 std::string ex(str, iter.base()); 12761 assert(ex == "+1.e+09******************"); 12762 assert(ios.width() == 0); 12763 } 12764 ios.width(25); 12765 right(ios); 12766 { 12767 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12768 std::string ex(str, iter.base()); 12769 assert(ex == "******************+1.e+09"); 12770 assert(ios.width() == 0); 12771 } 12772 ios.width(25); 12773 internal(ios); 12774 { 12775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12776 std::string ex(str, iter.base()); 12777 assert(ex == "+******************1.e+09"); 12778 assert(ios.width() == 0); 12779 } 12780 } 12781 ios.imbue(lg); 12782 { 12783 ios.width(0); 12784 { 12785 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12786 std::string ex(str, iter.base()); 12787 assert(ex == "+1;e+09"); 12788 assert(ios.width() == 0); 12789 } 12790 ios.width(25); 12791 left(ios); 12792 { 12793 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12794 std::string ex(str, iter.base()); 12795 assert(ex == "+1;e+09******************"); 12796 assert(ios.width() == 0); 12797 } 12798 ios.width(25); 12799 right(ios); 12800 { 12801 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12802 std::string ex(str, iter.base()); 12803 assert(ex == "******************+1;e+09"); 12804 assert(ios.width() == 0); 12805 } 12806 ios.width(25); 12807 internal(ios); 12808 { 12809 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12810 std::string ex(str, iter.base()); 12811 assert(ex == "+******************1;e+09"); 12812 assert(ios.width() == 0); 12813 } 12814 } 12815 } 12816 } 12817 } 12818 uppercase(ios); 12819 { 12820 noshowpos(ios); 12821 { 12822 noshowpoint(ios); 12823 { 12824 ios.imbue(lc); 12825 { 12826 ios.width(0); 12827 { 12828 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12829 std::string ex(str, iter.base()); 12830 assert(ex == "1E+09"); 12831 assert(ios.width() == 0); 12832 } 12833 ios.width(25); 12834 left(ios); 12835 { 12836 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12837 std::string ex(str, iter.base()); 12838 assert(ex == "1E+09********************"); 12839 assert(ios.width() == 0); 12840 } 12841 ios.width(25); 12842 right(ios); 12843 { 12844 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12845 std::string ex(str, iter.base()); 12846 assert(ex == "********************1E+09"); 12847 assert(ios.width() == 0); 12848 } 12849 ios.width(25); 12850 internal(ios); 12851 { 12852 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12853 std::string ex(str, iter.base()); 12854 assert(ex == "********************1E+09"); 12855 assert(ios.width() == 0); 12856 } 12857 } 12858 ios.imbue(lg); 12859 { 12860 ios.width(0); 12861 { 12862 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12863 std::string ex(str, iter.base()); 12864 assert(ex == "1E+09"); 12865 assert(ios.width() == 0); 12866 } 12867 ios.width(25); 12868 left(ios); 12869 { 12870 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12871 std::string ex(str, iter.base()); 12872 assert(ex == "1E+09********************"); 12873 assert(ios.width() == 0); 12874 } 12875 ios.width(25); 12876 right(ios); 12877 { 12878 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12879 std::string ex(str, iter.base()); 12880 assert(ex == "********************1E+09"); 12881 assert(ios.width() == 0); 12882 } 12883 ios.width(25); 12884 internal(ios); 12885 { 12886 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12887 std::string ex(str, iter.base()); 12888 assert(ex == "********************1E+09"); 12889 assert(ios.width() == 0); 12890 } 12891 } 12892 } 12893 showpoint(ios); 12894 { 12895 ios.imbue(lc); 12896 { 12897 ios.width(0); 12898 { 12899 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12900 std::string ex(str, iter.base()); 12901 assert(ex == "1.E+09"); 12902 assert(ios.width() == 0); 12903 } 12904 ios.width(25); 12905 left(ios); 12906 { 12907 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12908 std::string ex(str, iter.base()); 12909 assert(ex == "1.E+09*******************"); 12910 assert(ios.width() == 0); 12911 } 12912 ios.width(25); 12913 right(ios); 12914 { 12915 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12916 std::string ex(str, iter.base()); 12917 assert(ex == "*******************1.E+09"); 12918 assert(ios.width() == 0); 12919 } 12920 ios.width(25); 12921 internal(ios); 12922 { 12923 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12924 std::string ex(str, iter.base()); 12925 assert(ex == "*******************1.E+09"); 12926 assert(ios.width() == 0); 12927 } 12928 } 12929 ios.imbue(lg); 12930 { 12931 ios.width(0); 12932 { 12933 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12934 std::string ex(str, iter.base()); 12935 assert(ex == "1;E+09"); 12936 assert(ios.width() == 0); 12937 } 12938 ios.width(25); 12939 left(ios); 12940 { 12941 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12942 std::string ex(str, iter.base()); 12943 assert(ex == "1;E+09*******************"); 12944 assert(ios.width() == 0); 12945 } 12946 ios.width(25); 12947 right(ios); 12948 { 12949 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12950 std::string ex(str, iter.base()); 12951 assert(ex == "*******************1;E+09"); 12952 assert(ios.width() == 0); 12953 } 12954 ios.width(25); 12955 internal(ios); 12956 { 12957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12958 std::string ex(str, iter.base()); 12959 assert(ex == "*******************1;E+09"); 12960 assert(ios.width() == 0); 12961 } 12962 } 12963 } 12964 } 12965 showpos(ios); 12966 { 12967 noshowpoint(ios); 12968 { 12969 ios.imbue(lc); 12970 { 12971 ios.width(0); 12972 { 12973 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12974 std::string ex(str, iter.base()); 12975 assert(ex == "+1E+09"); 12976 assert(ios.width() == 0); 12977 } 12978 ios.width(25); 12979 left(ios); 12980 { 12981 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12982 std::string ex(str, iter.base()); 12983 assert(ex == "+1E+09*******************"); 12984 assert(ios.width() == 0); 12985 } 12986 ios.width(25); 12987 right(ios); 12988 { 12989 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12990 std::string ex(str, iter.base()); 12991 assert(ex == "*******************+1E+09"); 12992 assert(ios.width() == 0); 12993 } 12994 ios.width(25); 12995 internal(ios); 12996 { 12997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 12998 std::string ex(str, iter.base()); 12999 assert(ex == "+*******************1E+09"); 13000 assert(ios.width() == 0); 13001 } 13002 } 13003 ios.imbue(lg); 13004 { 13005 ios.width(0); 13006 { 13007 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13008 std::string ex(str, iter.base()); 13009 assert(ex == "+1E+09"); 13010 assert(ios.width() == 0); 13011 } 13012 ios.width(25); 13013 left(ios); 13014 { 13015 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13016 std::string ex(str, iter.base()); 13017 assert(ex == "+1E+09*******************"); 13018 assert(ios.width() == 0); 13019 } 13020 ios.width(25); 13021 right(ios); 13022 { 13023 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13024 std::string ex(str, iter.base()); 13025 assert(ex == "*******************+1E+09"); 13026 assert(ios.width() == 0); 13027 } 13028 ios.width(25); 13029 internal(ios); 13030 { 13031 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13032 std::string ex(str, iter.base()); 13033 assert(ex == "+*******************1E+09"); 13034 assert(ios.width() == 0); 13035 } 13036 } 13037 } 13038 showpoint(ios); 13039 { 13040 ios.imbue(lc); 13041 { 13042 ios.width(0); 13043 { 13044 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13045 std::string ex(str, iter.base()); 13046 assert(ex == "+1.E+09"); 13047 assert(ios.width() == 0); 13048 } 13049 ios.width(25); 13050 left(ios); 13051 { 13052 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13053 std::string ex(str, iter.base()); 13054 assert(ex == "+1.E+09******************"); 13055 assert(ios.width() == 0); 13056 } 13057 ios.width(25); 13058 right(ios); 13059 { 13060 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13061 std::string ex(str, iter.base()); 13062 assert(ex == "******************+1.E+09"); 13063 assert(ios.width() == 0); 13064 } 13065 ios.width(25); 13066 internal(ios); 13067 { 13068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13069 std::string ex(str, iter.base()); 13070 assert(ex == "+******************1.E+09"); 13071 assert(ios.width() == 0); 13072 } 13073 } 13074 ios.imbue(lg); 13075 { 13076 ios.width(0); 13077 { 13078 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13079 std::string ex(str, iter.base()); 13080 assert(ex == "+1;E+09"); 13081 assert(ios.width() == 0); 13082 } 13083 ios.width(25); 13084 left(ios); 13085 { 13086 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13087 std::string ex(str, iter.base()); 13088 assert(ex == "+1;E+09******************"); 13089 assert(ios.width() == 0); 13090 } 13091 ios.width(25); 13092 right(ios); 13093 { 13094 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13095 std::string ex(str, iter.base()); 13096 assert(ex == "******************+1;E+09"); 13097 assert(ios.width() == 0); 13098 } 13099 ios.width(25); 13100 internal(ios); 13101 { 13102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13103 std::string ex(str, iter.base()); 13104 assert(ex == "+******************1;E+09"); 13105 assert(ios.width() == 0); 13106 } 13107 } 13108 } 13109 } 13110 } 13111 } 13112 ios.precision(1); 13113 { 13114 nouppercase(ios); 13115 { 13116 noshowpos(ios); 13117 { 13118 noshowpoint(ios); 13119 { 13120 ios.imbue(lc); 13121 { 13122 ios.width(0); 13123 { 13124 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13125 std::string ex(str, iter.base()); 13126 assert(ex == "1.2e+09"); 13127 assert(ios.width() == 0); 13128 } 13129 ios.width(25); 13130 left(ios); 13131 { 13132 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13133 std::string ex(str, iter.base()); 13134 assert(ex == "1.2e+09******************"); 13135 assert(ios.width() == 0); 13136 } 13137 ios.width(25); 13138 right(ios); 13139 { 13140 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13141 std::string ex(str, iter.base()); 13142 assert(ex == "******************1.2e+09"); 13143 assert(ios.width() == 0); 13144 } 13145 ios.width(25); 13146 internal(ios); 13147 { 13148 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13149 std::string ex(str, iter.base()); 13150 assert(ex == "******************1.2e+09"); 13151 assert(ios.width() == 0); 13152 } 13153 } 13154 ios.imbue(lg); 13155 { 13156 ios.width(0); 13157 { 13158 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13159 std::string ex(str, iter.base()); 13160 assert(ex == "1;2e+09"); 13161 assert(ios.width() == 0); 13162 } 13163 ios.width(25); 13164 left(ios); 13165 { 13166 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13167 std::string ex(str, iter.base()); 13168 assert(ex == "1;2e+09******************"); 13169 assert(ios.width() == 0); 13170 } 13171 ios.width(25); 13172 right(ios); 13173 { 13174 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13175 std::string ex(str, iter.base()); 13176 assert(ex == "******************1;2e+09"); 13177 assert(ios.width() == 0); 13178 } 13179 ios.width(25); 13180 internal(ios); 13181 { 13182 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13183 std::string ex(str, iter.base()); 13184 assert(ex == "******************1;2e+09"); 13185 assert(ios.width() == 0); 13186 } 13187 } 13188 } 13189 showpoint(ios); 13190 { 13191 ios.imbue(lc); 13192 { 13193 ios.width(0); 13194 { 13195 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13196 std::string ex(str, iter.base()); 13197 assert(ex == "1.2e+09"); 13198 assert(ios.width() == 0); 13199 } 13200 ios.width(25); 13201 left(ios); 13202 { 13203 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13204 std::string ex(str, iter.base()); 13205 assert(ex == "1.2e+09******************"); 13206 assert(ios.width() == 0); 13207 } 13208 ios.width(25); 13209 right(ios); 13210 { 13211 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13212 std::string ex(str, iter.base()); 13213 assert(ex == "******************1.2e+09"); 13214 assert(ios.width() == 0); 13215 } 13216 ios.width(25); 13217 internal(ios); 13218 { 13219 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13220 std::string ex(str, iter.base()); 13221 assert(ex == "******************1.2e+09"); 13222 assert(ios.width() == 0); 13223 } 13224 } 13225 ios.imbue(lg); 13226 { 13227 ios.width(0); 13228 { 13229 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13230 std::string ex(str, iter.base()); 13231 assert(ex == "1;2e+09"); 13232 assert(ios.width() == 0); 13233 } 13234 ios.width(25); 13235 left(ios); 13236 { 13237 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13238 std::string ex(str, iter.base()); 13239 assert(ex == "1;2e+09******************"); 13240 assert(ios.width() == 0); 13241 } 13242 ios.width(25); 13243 right(ios); 13244 { 13245 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13246 std::string ex(str, iter.base()); 13247 assert(ex == "******************1;2e+09"); 13248 assert(ios.width() == 0); 13249 } 13250 ios.width(25); 13251 internal(ios); 13252 { 13253 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13254 std::string ex(str, iter.base()); 13255 assert(ex == "******************1;2e+09"); 13256 assert(ios.width() == 0); 13257 } 13258 } 13259 } 13260 } 13261 showpos(ios); 13262 { 13263 noshowpoint(ios); 13264 { 13265 ios.imbue(lc); 13266 { 13267 ios.width(0); 13268 { 13269 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13270 std::string ex(str, iter.base()); 13271 assert(ex == "+1.2e+09"); 13272 assert(ios.width() == 0); 13273 } 13274 ios.width(25); 13275 left(ios); 13276 { 13277 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13278 std::string ex(str, iter.base()); 13279 assert(ex == "+1.2e+09*****************"); 13280 assert(ios.width() == 0); 13281 } 13282 ios.width(25); 13283 right(ios); 13284 { 13285 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13286 std::string ex(str, iter.base()); 13287 assert(ex == "*****************+1.2e+09"); 13288 assert(ios.width() == 0); 13289 } 13290 ios.width(25); 13291 internal(ios); 13292 { 13293 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13294 std::string ex(str, iter.base()); 13295 assert(ex == "+*****************1.2e+09"); 13296 assert(ios.width() == 0); 13297 } 13298 } 13299 ios.imbue(lg); 13300 { 13301 ios.width(0); 13302 { 13303 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13304 std::string ex(str, iter.base()); 13305 assert(ex == "+1;2e+09"); 13306 assert(ios.width() == 0); 13307 } 13308 ios.width(25); 13309 left(ios); 13310 { 13311 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13312 std::string ex(str, iter.base()); 13313 assert(ex == "+1;2e+09*****************"); 13314 assert(ios.width() == 0); 13315 } 13316 ios.width(25); 13317 right(ios); 13318 { 13319 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13320 std::string ex(str, iter.base()); 13321 assert(ex == "*****************+1;2e+09"); 13322 assert(ios.width() == 0); 13323 } 13324 ios.width(25); 13325 internal(ios); 13326 { 13327 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13328 std::string ex(str, iter.base()); 13329 assert(ex == "+*****************1;2e+09"); 13330 assert(ios.width() == 0); 13331 } 13332 } 13333 } 13334 showpoint(ios); 13335 { 13336 ios.imbue(lc); 13337 { 13338 ios.width(0); 13339 { 13340 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13341 std::string ex(str, iter.base()); 13342 assert(ex == "+1.2e+09"); 13343 assert(ios.width() == 0); 13344 } 13345 ios.width(25); 13346 left(ios); 13347 { 13348 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13349 std::string ex(str, iter.base()); 13350 assert(ex == "+1.2e+09*****************"); 13351 assert(ios.width() == 0); 13352 } 13353 ios.width(25); 13354 right(ios); 13355 { 13356 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13357 std::string ex(str, iter.base()); 13358 assert(ex == "*****************+1.2e+09"); 13359 assert(ios.width() == 0); 13360 } 13361 ios.width(25); 13362 internal(ios); 13363 { 13364 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13365 std::string ex(str, iter.base()); 13366 assert(ex == "+*****************1.2e+09"); 13367 assert(ios.width() == 0); 13368 } 13369 } 13370 ios.imbue(lg); 13371 { 13372 ios.width(0); 13373 { 13374 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13375 std::string ex(str, iter.base()); 13376 assert(ex == "+1;2e+09"); 13377 assert(ios.width() == 0); 13378 } 13379 ios.width(25); 13380 left(ios); 13381 { 13382 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13383 std::string ex(str, iter.base()); 13384 assert(ex == "+1;2e+09*****************"); 13385 assert(ios.width() == 0); 13386 } 13387 ios.width(25); 13388 right(ios); 13389 { 13390 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13391 std::string ex(str, iter.base()); 13392 assert(ex == "*****************+1;2e+09"); 13393 assert(ios.width() == 0); 13394 } 13395 ios.width(25); 13396 internal(ios); 13397 { 13398 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13399 std::string ex(str, iter.base()); 13400 assert(ex == "+*****************1;2e+09"); 13401 assert(ios.width() == 0); 13402 } 13403 } 13404 } 13405 } 13406 } 13407 uppercase(ios); 13408 { 13409 noshowpos(ios); 13410 { 13411 noshowpoint(ios); 13412 { 13413 ios.imbue(lc); 13414 { 13415 ios.width(0); 13416 { 13417 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13418 std::string ex(str, iter.base()); 13419 assert(ex == "1.2E+09"); 13420 assert(ios.width() == 0); 13421 } 13422 ios.width(25); 13423 left(ios); 13424 { 13425 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13426 std::string ex(str, iter.base()); 13427 assert(ex == "1.2E+09******************"); 13428 assert(ios.width() == 0); 13429 } 13430 ios.width(25); 13431 right(ios); 13432 { 13433 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13434 std::string ex(str, iter.base()); 13435 assert(ex == "******************1.2E+09"); 13436 assert(ios.width() == 0); 13437 } 13438 ios.width(25); 13439 internal(ios); 13440 { 13441 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13442 std::string ex(str, iter.base()); 13443 assert(ex == "******************1.2E+09"); 13444 assert(ios.width() == 0); 13445 } 13446 } 13447 ios.imbue(lg); 13448 { 13449 ios.width(0); 13450 { 13451 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13452 std::string ex(str, iter.base()); 13453 assert(ex == "1;2E+09"); 13454 assert(ios.width() == 0); 13455 } 13456 ios.width(25); 13457 left(ios); 13458 { 13459 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13460 std::string ex(str, iter.base()); 13461 assert(ex == "1;2E+09******************"); 13462 assert(ios.width() == 0); 13463 } 13464 ios.width(25); 13465 right(ios); 13466 { 13467 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13468 std::string ex(str, iter.base()); 13469 assert(ex == "******************1;2E+09"); 13470 assert(ios.width() == 0); 13471 } 13472 ios.width(25); 13473 internal(ios); 13474 { 13475 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13476 std::string ex(str, iter.base()); 13477 assert(ex == "******************1;2E+09"); 13478 assert(ios.width() == 0); 13479 } 13480 } 13481 } 13482 showpoint(ios); 13483 { 13484 ios.imbue(lc); 13485 { 13486 ios.width(0); 13487 { 13488 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13489 std::string ex(str, iter.base()); 13490 assert(ex == "1.2E+09"); 13491 assert(ios.width() == 0); 13492 } 13493 ios.width(25); 13494 left(ios); 13495 { 13496 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13497 std::string ex(str, iter.base()); 13498 assert(ex == "1.2E+09******************"); 13499 assert(ios.width() == 0); 13500 } 13501 ios.width(25); 13502 right(ios); 13503 { 13504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13505 std::string ex(str, iter.base()); 13506 assert(ex == "******************1.2E+09"); 13507 assert(ios.width() == 0); 13508 } 13509 ios.width(25); 13510 internal(ios); 13511 { 13512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13513 std::string ex(str, iter.base()); 13514 assert(ex == "******************1.2E+09"); 13515 assert(ios.width() == 0); 13516 } 13517 } 13518 ios.imbue(lg); 13519 { 13520 ios.width(0); 13521 { 13522 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13523 std::string ex(str, iter.base()); 13524 assert(ex == "1;2E+09"); 13525 assert(ios.width() == 0); 13526 } 13527 ios.width(25); 13528 left(ios); 13529 { 13530 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13531 std::string ex(str, iter.base()); 13532 assert(ex == "1;2E+09******************"); 13533 assert(ios.width() == 0); 13534 } 13535 ios.width(25); 13536 right(ios); 13537 { 13538 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13539 std::string ex(str, iter.base()); 13540 assert(ex == "******************1;2E+09"); 13541 assert(ios.width() == 0); 13542 } 13543 ios.width(25); 13544 internal(ios); 13545 { 13546 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13547 std::string ex(str, iter.base()); 13548 assert(ex == "******************1;2E+09"); 13549 assert(ios.width() == 0); 13550 } 13551 } 13552 } 13553 } 13554 showpos(ios); 13555 { 13556 noshowpoint(ios); 13557 { 13558 ios.imbue(lc); 13559 { 13560 ios.width(0); 13561 { 13562 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13563 std::string ex(str, iter.base()); 13564 assert(ex == "+1.2E+09"); 13565 assert(ios.width() == 0); 13566 } 13567 ios.width(25); 13568 left(ios); 13569 { 13570 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13571 std::string ex(str, iter.base()); 13572 assert(ex == "+1.2E+09*****************"); 13573 assert(ios.width() == 0); 13574 } 13575 ios.width(25); 13576 right(ios); 13577 { 13578 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13579 std::string ex(str, iter.base()); 13580 assert(ex == "*****************+1.2E+09"); 13581 assert(ios.width() == 0); 13582 } 13583 ios.width(25); 13584 internal(ios); 13585 { 13586 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13587 std::string ex(str, iter.base()); 13588 assert(ex == "+*****************1.2E+09"); 13589 assert(ios.width() == 0); 13590 } 13591 } 13592 ios.imbue(lg); 13593 { 13594 ios.width(0); 13595 { 13596 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13597 std::string ex(str, iter.base()); 13598 assert(ex == "+1;2E+09"); 13599 assert(ios.width() == 0); 13600 } 13601 ios.width(25); 13602 left(ios); 13603 { 13604 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13605 std::string ex(str, iter.base()); 13606 assert(ex == "+1;2E+09*****************"); 13607 assert(ios.width() == 0); 13608 } 13609 ios.width(25); 13610 right(ios); 13611 { 13612 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13613 std::string ex(str, iter.base()); 13614 assert(ex == "*****************+1;2E+09"); 13615 assert(ios.width() == 0); 13616 } 13617 ios.width(25); 13618 internal(ios); 13619 { 13620 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13621 std::string ex(str, iter.base()); 13622 assert(ex == "+*****************1;2E+09"); 13623 assert(ios.width() == 0); 13624 } 13625 } 13626 } 13627 showpoint(ios); 13628 { 13629 ios.imbue(lc); 13630 { 13631 ios.width(0); 13632 { 13633 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13634 std::string ex(str, iter.base()); 13635 assert(ex == "+1.2E+09"); 13636 assert(ios.width() == 0); 13637 } 13638 ios.width(25); 13639 left(ios); 13640 { 13641 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13642 std::string ex(str, iter.base()); 13643 assert(ex == "+1.2E+09*****************"); 13644 assert(ios.width() == 0); 13645 } 13646 ios.width(25); 13647 right(ios); 13648 { 13649 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13650 std::string ex(str, iter.base()); 13651 assert(ex == "*****************+1.2E+09"); 13652 assert(ios.width() == 0); 13653 } 13654 ios.width(25); 13655 internal(ios); 13656 { 13657 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13658 std::string ex(str, iter.base()); 13659 assert(ex == "+*****************1.2E+09"); 13660 assert(ios.width() == 0); 13661 } 13662 } 13663 ios.imbue(lg); 13664 { 13665 ios.width(0); 13666 { 13667 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13668 std::string ex(str, iter.base()); 13669 assert(ex == "+1;2E+09"); 13670 assert(ios.width() == 0); 13671 } 13672 ios.width(25); 13673 left(ios); 13674 { 13675 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13676 std::string ex(str, iter.base()); 13677 assert(ex == "+1;2E+09*****************"); 13678 assert(ios.width() == 0); 13679 } 13680 ios.width(25); 13681 right(ios); 13682 { 13683 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13684 std::string ex(str, iter.base()); 13685 assert(ex == "*****************+1;2E+09"); 13686 assert(ios.width() == 0); 13687 } 13688 ios.width(25); 13689 internal(ios); 13690 { 13691 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13692 std::string ex(str, iter.base()); 13693 assert(ex == "+*****************1;2E+09"); 13694 assert(ios.width() == 0); 13695 } 13696 } 13697 } 13698 } 13699 } 13700 } 13701 ios.precision(6); 13702 { 13703 } 13704 ios.precision(16); 13705 { 13706 } 13707 ios.precision(60); 13708 { 13709 nouppercase(ios); 13710 { 13711 noshowpos(ios); 13712 { 13713 noshowpoint(ios); 13714 { 13715 ios.imbue(lc); 13716 { 13717 ios.width(0); 13718 { 13719 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13720 std::string ex(str, iter.base()); 13721 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 13722 assert(ios.width() == 0); 13723 } 13724 ios.width(25); 13725 left(ios); 13726 { 13727 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13728 std::string ex(str, iter.base()); 13729 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 13730 assert(ios.width() == 0); 13731 } 13732 ios.width(25); 13733 right(ios); 13734 { 13735 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13736 std::string ex(str, iter.base()); 13737 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 13738 assert(ios.width() == 0); 13739 } 13740 ios.width(25); 13741 internal(ios); 13742 { 13743 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13744 std::string ex(str, iter.base()); 13745 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 13746 assert(ios.width() == 0); 13747 } 13748 } 13749 ios.imbue(lg); 13750 { 13751 ios.width(0); 13752 { 13753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13754 std::string ex(str, iter.base()); 13755 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 13756 assert(ios.width() == 0); 13757 } 13758 ios.width(25); 13759 left(ios); 13760 { 13761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13762 std::string ex(str, iter.base()); 13763 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 13764 assert(ios.width() == 0); 13765 } 13766 ios.width(25); 13767 right(ios); 13768 { 13769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13770 std::string ex(str, iter.base()); 13771 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 13772 assert(ios.width() == 0); 13773 } 13774 ios.width(25); 13775 internal(ios); 13776 { 13777 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13778 std::string ex(str, iter.base()); 13779 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 13780 assert(ios.width() == 0); 13781 } 13782 } 13783 } 13784 showpoint(ios); 13785 { 13786 ios.imbue(lc); 13787 { 13788 ios.width(0); 13789 { 13790 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13791 std::string ex(str, iter.base()); 13792 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 13793 assert(ios.width() == 0); 13794 } 13795 ios.width(25); 13796 left(ios); 13797 { 13798 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13799 std::string ex(str, iter.base()); 13800 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 13801 assert(ios.width() == 0); 13802 } 13803 ios.width(25); 13804 right(ios); 13805 { 13806 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13807 std::string ex(str, iter.base()); 13808 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 13809 assert(ios.width() == 0); 13810 } 13811 ios.width(25); 13812 internal(ios); 13813 { 13814 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13815 std::string ex(str, iter.base()); 13816 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000e+09"); 13817 assert(ios.width() == 0); 13818 } 13819 } 13820 ios.imbue(lg); 13821 { 13822 ios.width(0); 13823 { 13824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13825 std::string ex(str, iter.base()); 13826 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 13827 assert(ios.width() == 0); 13828 } 13829 ios.width(25); 13830 left(ios); 13831 { 13832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13833 std::string ex(str, iter.base()); 13834 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 13835 assert(ios.width() == 0); 13836 } 13837 ios.width(25); 13838 right(ios); 13839 { 13840 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13841 std::string ex(str, iter.base()); 13842 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 13843 assert(ios.width() == 0); 13844 } 13845 ios.width(25); 13846 internal(ios); 13847 { 13848 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13849 std::string ex(str, iter.base()); 13850 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000e+09"); 13851 assert(ios.width() == 0); 13852 } 13853 } 13854 } 13855 } 13856 showpos(ios); 13857 { 13858 noshowpoint(ios); 13859 { 13860 ios.imbue(lc); 13861 { 13862 ios.width(0); 13863 { 13864 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13865 std::string ex(str, iter.base()); 13866 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 13867 assert(ios.width() == 0); 13868 } 13869 ios.width(25); 13870 left(ios); 13871 { 13872 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13873 std::string ex(str, iter.base()); 13874 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 13875 assert(ios.width() == 0); 13876 } 13877 ios.width(25); 13878 right(ios); 13879 { 13880 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13881 std::string ex(str, iter.base()); 13882 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 13883 assert(ios.width() == 0); 13884 } 13885 ios.width(25); 13886 internal(ios); 13887 { 13888 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13889 std::string ex(str, iter.base()); 13890 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 13891 assert(ios.width() == 0); 13892 } 13893 } 13894 ios.imbue(lg); 13895 { 13896 ios.width(0); 13897 { 13898 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13899 std::string ex(str, iter.base()); 13900 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 13901 assert(ios.width() == 0); 13902 } 13903 ios.width(25); 13904 left(ios); 13905 { 13906 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13907 std::string ex(str, iter.base()); 13908 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 13909 assert(ios.width() == 0); 13910 } 13911 ios.width(25); 13912 right(ios); 13913 { 13914 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13915 std::string ex(str, iter.base()); 13916 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 13917 assert(ios.width() == 0); 13918 } 13919 ios.width(25); 13920 internal(ios); 13921 { 13922 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13923 std::string ex(str, iter.base()); 13924 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 13925 assert(ios.width() == 0); 13926 } 13927 } 13928 } 13929 showpoint(ios); 13930 { 13931 ios.imbue(lc); 13932 { 13933 ios.width(0); 13934 { 13935 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13936 std::string ex(str, iter.base()); 13937 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 13938 assert(ios.width() == 0); 13939 } 13940 ios.width(25); 13941 left(ios); 13942 { 13943 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13944 std::string ex(str, iter.base()); 13945 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 13946 assert(ios.width() == 0); 13947 } 13948 ios.width(25); 13949 right(ios); 13950 { 13951 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13952 std::string ex(str, iter.base()); 13953 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 13954 assert(ios.width() == 0); 13955 } 13956 ios.width(25); 13957 internal(ios); 13958 { 13959 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13960 std::string ex(str, iter.base()); 13961 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000e+09"); 13962 assert(ios.width() == 0); 13963 } 13964 } 13965 ios.imbue(lg); 13966 { 13967 ios.width(0); 13968 { 13969 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13970 std::string ex(str, iter.base()); 13971 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 13972 assert(ios.width() == 0); 13973 } 13974 ios.width(25); 13975 left(ios); 13976 { 13977 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13978 std::string ex(str, iter.base()); 13979 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 13980 assert(ios.width() == 0); 13981 } 13982 ios.width(25); 13983 right(ios); 13984 { 13985 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13986 std::string ex(str, iter.base()); 13987 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 13988 assert(ios.width() == 0); 13989 } 13990 ios.width(25); 13991 internal(ios); 13992 { 13993 iter = f.put(output_iterator<char*>(str), ios, '*', v); 13994 std::string ex(str, iter.base()); 13995 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000e+09"); 13996 assert(ios.width() == 0); 13997 } 13998 } 13999 } 14000 } 14001 } 14002 uppercase(ios); 14003 { 14004 noshowpos(ios); 14005 { 14006 noshowpoint(ios); 14007 { 14008 ios.imbue(lc); 14009 { 14010 ios.width(0); 14011 { 14012 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14013 std::string ex(str, iter.base()); 14014 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 14015 assert(ios.width() == 0); 14016 } 14017 ios.width(25); 14018 left(ios); 14019 { 14020 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14021 std::string ex(str, iter.base()); 14022 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 14023 assert(ios.width() == 0); 14024 } 14025 ios.width(25); 14026 right(ios); 14027 { 14028 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14029 std::string ex(str, iter.base()); 14030 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 14031 assert(ios.width() == 0); 14032 } 14033 ios.width(25); 14034 internal(ios); 14035 { 14036 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14037 std::string ex(str, iter.base()); 14038 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 14039 assert(ios.width() == 0); 14040 } 14041 } 14042 ios.imbue(lg); 14043 { 14044 ios.width(0); 14045 { 14046 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14047 std::string ex(str, iter.base()); 14048 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 14049 assert(ios.width() == 0); 14050 } 14051 ios.width(25); 14052 left(ios); 14053 { 14054 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14055 std::string ex(str, iter.base()); 14056 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 14057 assert(ios.width() == 0); 14058 } 14059 ios.width(25); 14060 right(ios); 14061 { 14062 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14063 std::string ex(str, iter.base()); 14064 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 14065 assert(ios.width() == 0); 14066 } 14067 ios.width(25); 14068 internal(ios); 14069 { 14070 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14071 std::string ex(str, iter.base()); 14072 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 14073 assert(ios.width() == 0); 14074 } 14075 } 14076 } 14077 showpoint(ios); 14078 { 14079 ios.imbue(lc); 14080 { 14081 ios.width(0); 14082 { 14083 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14084 std::string ex(str, iter.base()); 14085 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 14086 assert(ios.width() == 0); 14087 } 14088 ios.width(25); 14089 left(ios); 14090 { 14091 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14092 std::string ex(str, iter.base()); 14093 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 14094 assert(ios.width() == 0); 14095 } 14096 ios.width(25); 14097 right(ios); 14098 { 14099 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14100 std::string ex(str, iter.base()); 14101 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 14102 assert(ios.width() == 0); 14103 } 14104 ios.width(25); 14105 internal(ios); 14106 { 14107 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14108 std::string ex(str, iter.base()); 14109 assert(ex == "1.234567890125000000000000000000000000000000000000000000000000E+09"); 14110 assert(ios.width() == 0); 14111 } 14112 } 14113 ios.imbue(lg); 14114 { 14115 ios.width(0); 14116 { 14117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14118 std::string ex(str, iter.base()); 14119 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 14120 assert(ios.width() == 0); 14121 } 14122 ios.width(25); 14123 left(ios); 14124 { 14125 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14126 std::string ex(str, iter.base()); 14127 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 14128 assert(ios.width() == 0); 14129 } 14130 ios.width(25); 14131 right(ios); 14132 { 14133 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14134 std::string ex(str, iter.base()); 14135 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 14136 assert(ios.width() == 0); 14137 } 14138 ios.width(25); 14139 internal(ios); 14140 { 14141 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14142 std::string ex(str, iter.base()); 14143 assert(ex == "1;234567890125000000000000000000000000000000000000000000000000E+09"); 14144 assert(ios.width() == 0); 14145 } 14146 } 14147 } 14148 } 14149 showpos(ios); 14150 { 14151 noshowpoint(ios); 14152 { 14153 ios.imbue(lc); 14154 { 14155 ios.width(0); 14156 { 14157 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14158 std::string ex(str, iter.base()); 14159 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 14160 assert(ios.width() == 0); 14161 } 14162 ios.width(25); 14163 left(ios); 14164 { 14165 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14166 std::string ex(str, iter.base()); 14167 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 14168 assert(ios.width() == 0); 14169 } 14170 ios.width(25); 14171 right(ios); 14172 { 14173 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14174 std::string ex(str, iter.base()); 14175 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 14176 assert(ios.width() == 0); 14177 } 14178 ios.width(25); 14179 internal(ios); 14180 { 14181 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14182 std::string ex(str, iter.base()); 14183 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 14184 assert(ios.width() == 0); 14185 } 14186 } 14187 ios.imbue(lg); 14188 { 14189 ios.width(0); 14190 { 14191 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14192 std::string ex(str, iter.base()); 14193 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 14194 assert(ios.width() == 0); 14195 } 14196 ios.width(25); 14197 left(ios); 14198 { 14199 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14200 std::string ex(str, iter.base()); 14201 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 14202 assert(ios.width() == 0); 14203 } 14204 ios.width(25); 14205 right(ios); 14206 { 14207 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14208 std::string ex(str, iter.base()); 14209 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 14210 assert(ios.width() == 0); 14211 } 14212 ios.width(25); 14213 internal(ios); 14214 { 14215 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14216 std::string ex(str, iter.base()); 14217 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 14218 assert(ios.width() == 0); 14219 } 14220 } 14221 } 14222 showpoint(ios); 14223 { 14224 ios.imbue(lc); 14225 { 14226 ios.width(0); 14227 { 14228 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14229 std::string ex(str, iter.base()); 14230 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 14231 assert(ios.width() == 0); 14232 } 14233 ios.width(25); 14234 left(ios); 14235 { 14236 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14237 std::string ex(str, iter.base()); 14238 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 14239 assert(ios.width() == 0); 14240 } 14241 ios.width(25); 14242 right(ios); 14243 { 14244 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14245 std::string ex(str, iter.base()); 14246 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 14247 assert(ios.width() == 0); 14248 } 14249 ios.width(25); 14250 internal(ios); 14251 { 14252 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14253 std::string ex(str, iter.base()); 14254 assert(ex == "+1.234567890125000000000000000000000000000000000000000000000000E+09"); 14255 assert(ios.width() == 0); 14256 } 14257 } 14258 ios.imbue(lg); 14259 { 14260 ios.width(0); 14261 { 14262 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14263 std::string ex(str, iter.base()); 14264 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 14265 assert(ios.width() == 0); 14266 } 14267 ios.width(25); 14268 left(ios); 14269 { 14270 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14271 std::string ex(str, iter.base()); 14272 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 14273 assert(ios.width() == 0); 14274 } 14275 ios.width(25); 14276 right(ios); 14277 { 14278 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14279 std::string ex(str, iter.base()); 14280 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 14281 assert(ios.width() == 0); 14282 } 14283 ios.width(25); 14284 internal(ios); 14285 { 14286 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14287 std::string ex(str, iter.base()); 14288 assert(ex == "+1;234567890125000000000000000000000000000000000000000000000000E+09"); 14289 assert(ios.width() == 0); 14290 } 14291 } 14292 } 14293 } 14294 } 14295 } 14296 } 14297 } 14298 } 14299 14300 void test7() 14301 { 14302 char str[200]; 14303 output_iterator<char*> iter; 14304 std::locale lc = std::locale::classic(); 14305 std::locale lg(lc, new my_numpunct); 14306 const my_facet f(1); 14307 { 14308 double v = -0.; 14309 std::ios ios(0); 14310 hexfloat(ios); 14311 // %a 14312 { 14313 ios.precision(0); 14314 { 14315 nouppercase(ios); 14316 { 14317 noshowpos(ios); 14318 { 14319 noshowpoint(ios); 14320 { 14321 ios.imbue(lc); 14322 { 14323 ios.width(0); 14324 { 14325 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14326 std::string ex(str, iter.base()); 14327 assert(ex == "-0x0p+0"); 14328 assert(ios.width() == 0); 14329 } 14330 ios.width(25); 14331 left(ios); 14332 { 14333 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14334 std::string ex(str, iter.base()); 14335 assert(ex == "-0x0p+0******************"); 14336 assert(ios.width() == 0); 14337 } 14338 ios.width(25); 14339 right(ios); 14340 { 14341 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14342 std::string ex(str, iter.base()); 14343 assert(ex == "******************-0x0p+0"); 14344 assert(ios.width() == 0); 14345 } 14346 ios.width(25); 14347 internal(ios); 14348 { 14349 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14350 std::string ex(str, iter.base()); 14351 assert(ex == "-******************0x0p+0"); 14352 assert(ios.width() == 0); 14353 } 14354 } 14355 ios.imbue(lg); 14356 { 14357 ios.width(0); 14358 { 14359 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14360 std::string ex(str, iter.base()); 14361 assert(ex == "-0x0p+0"); 14362 assert(ios.width() == 0); 14363 } 14364 ios.width(25); 14365 left(ios); 14366 { 14367 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14368 std::string ex(str, iter.base()); 14369 assert(ex == "-0x0p+0******************"); 14370 assert(ios.width() == 0); 14371 } 14372 ios.width(25); 14373 right(ios); 14374 { 14375 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14376 std::string ex(str, iter.base()); 14377 assert(ex == "******************-0x0p+0"); 14378 assert(ios.width() == 0); 14379 } 14380 ios.width(25); 14381 internal(ios); 14382 { 14383 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14384 std::string ex(str, iter.base()); 14385 assert(ex == "-******************0x0p+0"); 14386 assert(ios.width() == 0); 14387 } 14388 } 14389 } 14390 showpoint(ios); 14391 { 14392 ios.imbue(lc); 14393 { 14394 ios.width(0); 14395 { 14396 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14397 std::string ex(str, iter.base()); 14398 assert(ex == "-0x0.p+0"); 14399 assert(ios.width() == 0); 14400 } 14401 ios.width(25); 14402 left(ios); 14403 { 14404 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14405 std::string ex(str, iter.base()); 14406 assert(ex == "-0x0.p+0*****************"); 14407 assert(ios.width() == 0); 14408 } 14409 ios.width(25); 14410 right(ios); 14411 { 14412 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14413 std::string ex(str, iter.base()); 14414 assert(ex == "*****************-0x0.p+0"); 14415 assert(ios.width() == 0); 14416 } 14417 ios.width(25); 14418 internal(ios); 14419 { 14420 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14421 std::string ex(str, iter.base()); 14422 assert(ex == "-*****************0x0.p+0"); 14423 assert(ios.width() == 0); 14424 } 14425 } 14426 ios.imbue(lg); 14427 { 14428 ios.width(0); 14429 { 14430 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14431 std::string ex(str, iter.base()); 14432 assert(ex == "-0x0;p+0"); 14433 assert(ios.width() == 0); 14434 } 14435 ios.width(25); 14436 left(ios); 14437 { 14438 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14439 std::string ex(str, iter.base()); 14440 assert(ex == "-0x0;p+0*****************"); 14441 assert(ios.width() == 0); 14442 } 14443 ios.width(25); 14444 right(ios); 14445 { 14446 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14447 std::string ex(str, iter.base()); 14448 assert(ex == "*****************-0x0;p+0"); 14449 assert(ios.width() == 0); 14450 } 14451 ios.width(25); 14452 internal(ios); 14453 { 14454 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14455 std::string ex(str, iter.base()); 14456 assert(ex == "-*****************0x0;p+0"); 14457 assert(ios.width() == 0); 14458 } 14459 } 14460 } 14461 } 14462 showpos(ios); 14463 { 14464 noshowpoint(ios); 14465 { 14466 ios.imbue(lc); 14467 { 14468 ios.width(0); 14469 { 14470 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14471 std::string ex(str, iter.base()); 14472 assert(ex == "-0x0p+0"); 14473 assert(ios.width() == 0); 14474 } 14475 ios.width(25); 14476 left(ios); 14477 { 14478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14479 std::string ex(str, iter.base()); 14480 assert(ex == "-0x0p+0******************"); 14481 assert(ios.width() == 0); 14482 } 14483 ios.width(25); 14484 right(ios); 14485 { 14486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14487 std::string ex(str, iter.base()); 14488 assert(ex == "******************-0x0p+0"); 14489 assert(ios.width() == 0); 14490 } 14491 ios.width(25); 14492 internal(ios); 14493 { 14494 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14495 std::string ex(str, iter.base()); 14496 assert(ex == "-******************0x0p+0"); 14497 assert(ios.width() == 0); 14498 } 14499 } 14500 ios.imbue(lg); 14501 { 14502 ios.width(0); 14503 { 14504 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14505 std::string ex(str, iter.base()); 14506 assert(ex == "-0x0p+0"); 14507 assert(ios.width() == 0); 14508 } 14509 ios.width(25); 14510 left(ios); 14511 { 14512 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14513 std::string ex(str, iter.base()); 14514 assert(ex == "-0x0p+0******************"); 14515 assert(ios.width() == 0); 14516 } 14517 ios.width(25); 14518 right(ios); 14519 { 14520 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14521 std::string ex(str, iter.base()); 14522 assert(ex == "******************-0x0p+0"); 14523 assert(ios.width() == 0); 14524 } 14525 ios.width(25); 14526 internal(ios); 14527 { 14528 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14529 std::string ex(str, iter.base()); 14530 assert(ex == "-******************0x0p+0"); 14531 assert(ios.width() == 0); 14532 } 14533 } 14534 } 14535 showpoint(ios); 14536 { 14537 ios.imbue(lc); 14538 { 14539 ios.width(0); 14540 { 14541 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14542 std::string ex(str, iter.base()); 14543 assert(ex == "-0x0.p+0"); 14544 assert(ios.width() == 0); 14545 } 14546 ios.width(25); 14547 left(ios); 14548 { 14549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14550 std::string ex(str, iter.base()); 14551 assert(ex == "-0x0.p+0*****************"); 14552 assert(ios.width() == 0); 14553 } 14554 ios.width(25); 14555 right(ios); 14556 { 14557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14558 std::string ex(str, iter.base()); 14559 assert(ex == "*****************-0x0.p+0"); 14560 assert(ios.width() == 0); 14561 } 14562 ios.width(25); 14563 internal(ios); 14564 { 14565 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14566 std::string ex(str, iter.base()); 14567 assert(ex == "-*****************0x0.p+0"); 14568 assert(ios.width() == 0); 14569 } 14570 } 14571 ios.imbue(lg); 14572 { 14573 ios.width(0); 14574 { 14575 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14576 std::string ex(str, iter.base()); 14577 assert(ex == "-0x0;p+0"); 14578 assert(ios.width() == 0); 14579 } 14580 ios.width(25); 14581 left(ios); 14582 { 14583 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14584 std::string ex(str, iter.base()); 14585 assert(ex == "-0x0;p+0*****************"); 14586 assert(ios.width() == 0); 14587 } 14588 ios.width(25); 14589 right(ios); 14590 { 14591 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14592 std::string ex(str, iter.base()); 14593 assert(ex == "*****************-0x0;p+0"); 14594 assert(ios.width() == 0); 14595 } 14596 ios.width(25); 14597 internal(ios); 14598 { 14599 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14600 std::string ex(str, iter.base()); 14601 assert(ex == "-*****************0x0;p+0"); 14602 assert(ios.width() == 0); 14603 } 14604 } 14605 } 14606 } 14607 } 14608 uppercase(ios); 14609 { 14610 noshowpos(ios); 14611 { 14612 noshowpoint(ios); 14613 { 14614 ios.imbue(lc); 14615 { 14616 ios.width(0); 14617 { 14618 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14619 std::string ex(str, iter.base()); 14620 assert(ex == "-0X0P+0"); 14621 assert(ios.width() == 0); 14622 } 14623 ios.width(25); 14624 left(ios); 14625 { 14626 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14627 std::string ex(str, iter.base()); 14628 assert(ex == "-0X0P+0******************"); 14629 assert(ios.width() == 0); 14630 } 14631 ios.width(25); 14632 right(ios); 14633 { 14634 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14635 std::string ex(str, iter.base()); 14636 assert(ex == "******************-0X0P+0"); 14637 assert(ios.width() == 0); 14638 } 14639 ios.width(25); 14640 internal(ios); 14641 { 14642 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14643 std::string ex(str, iter.base()); 14644 assert(ex == "-******************0X0P+0"); 14645 assert(ios.width() == 0); 14646 } 14647 } 14648 ios.imbue(lg); 14649 { 14650 ios.width(0); 14651 { 14652 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14653 std::string ex(str, iter.base()); 14654 assert(ex == "-0X0P+0"); 14655 assert(ios.width() == 0); 14656 } 14657 ios.width(25); 14658 left(ios); 14659 { 14660 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14661 std::string ex(str, iter.base()); 14662 assert(ex == "-0X0P+0******************"); 14663 assert(ios.width() == 0); 14664 } 14665 ios.width(25); 14666 right(ios); 14667 { 14668 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14669 std::string ex(str, iter.base()); 14670 assert(ex == "******************-0X0P+0"); 14671 assert(ios.width() == 0); 14672 } 14673 ios.width(25); 14674 internal(ios); 14675 { 14676 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14677 std::string ex(str, iter.base()); 14678 assert(ex == "-******************0X0P+0"); 14679 assert(ios.width() == 0); 14680 } 14681 } 14682 } 14683 showpoint(ios); 14684 { 14685 ios.imbue(lc); 14686 { 14687 ios.width(0); 14688 { 14689 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14690 std::string ex(str, iter.base()); 14691 assert(ex == "-0X0.P+0"); 14692 assert(ios.width() == 0); 14693 } 14694 ios.width(25); 14695 left(ios); 14696 { 14697 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14698 std::string ex(str, iter.base()); 14699 assert(ex == "-0X0.P+0*****************"); 14700 assert(ios.width() == 0); 14701 } 14702 ios.width(25); 14703 right(ios); 14704 { 14705 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14706 std::string ex(str, iter.base()); 14707 assert(ex == "*****************-0X0.P+0"); 14708 assert(ios.width() == 0); 14709 } 14710 ios.width(25); 14711 internal(ios); 14712 { 14713 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14714 std::string ex(str, iter.base()); 14715 assert(ex == "-*****************0X0.P+0"); 14716 assert(ios.width() == 0); 14717 } 14718 } 14719 ios.imbue(lg); 14720 { 14721 ios.width(0); 14722 { 14723 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14724 std::string ex(str, iter.base()); 14725 assert(ex == "-0X0;P+0"); 14726 assert(ios.width() == 0); 14727 } 14728 ios.width(25); 14729 left(ios); 14730 { 14731 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14732 std::string ex(str, iter.base()); 14733 assert(ex == "-0X0;P+0*****************"); 14734 assert(ios.width() == 0); 14735 } 14736 ios.width(25); 14737 right(ios); 14738 { 14739 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14740 std::string ex(str, iter.base()); 14741 assert(ex == "*****************-0X0;P+0"); 14742 assert(ios.width() == 0); 14743 } 14744 ios.width(25); 14745 internal(ios); 14746 { 14747 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14748 std::string ex(str, iter.base()); 14749 assert(ex == "-*****************0X0;P+0"); 14750 assert(ios.width() == 0); 14751 } 14752 } 14753 } 14754 } 14755 showpos(ios); 14756 { 14757 noshowpoint(ios); 14758 { 14759 ios.imbue(lc); 14760 { 14761 ios.width(0); 14762 { 14763 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14764 std::string ex(str, iter.base()); 14765 assert(ex == "-0X0P+0"); 14766 assert(ios.width() == 0); 14767 } 14768 ios.width(25); 14769 left(ios); 14770 { 14771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14772 std::string ex(str, iter.base()); 14773 assert(ex == "-0X0P+0******************"); 14774 assert(ios.width() == 0); 14775 } 14776 ios.width(25); 14777 right(ios); 14778 { 14779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14780 std::string ex(str, iter.base()); 14781 assert(ex == "******************-0X0P+0"); 14782 assert(ios.width() == 0); 14783 } 14784 ios.width(25); 14785 internal(ios); 14786 { 14787 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14788 std::string ex(str, iter.base()); 14789 assert(ex == "-******************0X0P+0"); 14790 assert(ios.width() == 0); 14791 } 14792 } 14793 ios.imbue(lg); 14794 { 14795 ios.width(0); 14796 { 14797 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14798 std::string ex(str, iter.base()); 14799 assert(ex == "-0X0P+0"); 14800 assert(ios.width() == 0); 14801 } 14802 ios.width(25); 14803 left(ios); 14804 { 14805 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14806 std::string ex(str, iter.base()); 14807 assert(ex == "-0X0P+0******************"); 14808 assert(ios.width() == 0); 14809 } 14810 ios.width(25); 14811 right(ios); 14812 { 14813 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14814 std::string ex(str, iter.base()); 14815 assert(ex == "******************-0X0P+0"); 14816 assert(ios.width() == 0); 14817 } 14818 ios.width(25); 14819 internal(ios); 14820 { 14821 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14822 std::string ex(str, iter.base()); 14823 assert(ex == "-******************0X0P+0"); 14824 assert(ios.width() == 0); 14825 } 14826 } 14827 } 14828 showpoint(ios); 14829 { 14830 ios.imbue(lc); 14831 { 14832 ios.width(0); 14833 { 14834 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14835 std::string ex(str, iter.base()); 14836 assert(ex == "-0X0.P+0"); 14837 assert(ios.width() == 0); 14838 } 14839 ios.width(25); 14840 left(ios); 14841 { 14842 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14843 std::string ex(str, iter.base()); 14844 assert(ex == "-0X0.P+0*****************"); 14845 assert(ios.width() == 0); 14846 } 14847 ios.width(25); 14848 right(ios); 14849 { 14850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14851 std::string ex(str, iter.base()); 14852 assert(ex == "*****************-0X0.P+0"); 14853 assert(ios.width() == 0); 14854 } 14855 ios.width(25); 14856 internal(ios); 14857 { 14858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14859 std::string ex(str, iter.base()); 14860 assert(ex == "-*****************0X0.P+0"); 14861 assert(ios.width() == 0); 14862 } 14863 } 14864 ios.imbue(lg); 14865 { 14866 ios.width(0); 14867 { 14868 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14869 std::string ex(str, iter.base()); 14870 assert(ex == "-0X0;P+0"); 14871 assert(ios.width() == 0); 14872 } 14873 ios.width(25); 14874 left(ios); 14875 { 14876 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14877 std::string ex(str, iter.base()); 14878 assert(ex == "-0X0;P+0*****************"); 14879 assert(ios.width() == 0); 14880 } 14881 ios.width(25); 14882 right(ios); 14883 { 14884 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14885 std::string ex(str, iter.base()); 14886 assert(ex == "*****************-0X0;P+0"); 14887 assert(ios.width() == 0); 14888 } 14889 ios.width(25); 14890 internal(ios); 14891 { 14892 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14893 std::string ex(str, iter.base()); 14894 assert(ex == "-*****************0X0;P+0"); 14895 assert(ios.width() == 0); 14896 } 14897 } 14898 } 14899 } 14900 } 14901 } 14902 ios.precision(1); 14903 { 14904 nouppercase(ios); 14905 { 14906 noshowpos(ios); 14907 { 14908 noshowpoint(ios); 14909 { 14910 ios.imbue(lc); 14911 { 14912 ios.width(0); 14913 { 14914 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14915 std::string ex(str, iter.base()); 14916 assert(ex == "-0x0p+0"); 14917 assert(ios.width() == 0); 14918 } 14919 ios.width(25); 14920 left(ios); 14921 { 14922 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14923 std::string ex(str, iter.base()); 14924 assert(ex == "-0x0p+0******************"); 14925 assert(ios.width() == 0); 14926 } 14927 ios.width(25); 14928 right(ios); 14929 { 14930 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14931 std::string ex(str, iter.base()); 14932 assert(ex == "******************-0x0p+0"); 14933 assert(ios.width() == 0); 14934 } 14935 ios.width(25); 14936 internal(ios); 14937 { 14938 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14939 std::string ex(str, iter.base()); 14940 assert(ex == "-******************0x0p+0"); 14941 assert(ios.width() == 0); 14942 } 14943 } 14944 ios.imbue(lg); 14945 { 14946 ios.width(0); 14947 { 14948 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14949 std::string ex(str, iter.base()); 14950 assert(ex == "-0x0p+0"); 14951 assert(ios.width() == 0); 14952 } 14953 ios.width(25); 14954 left(ios); 14955 { 14956 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14957 std::string ex(str, iter.base()); 14958 assert(ex == "-0x0p+0******************"); 14959 assert(ios.width() == 0); 14960 } 14961 ios.width(25); 14962 right(ios); 14963 { 14964 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14965 std::string ex(str, iter.base()); 14966 assert(ex == "******************-0x0p+0"); 14967 assert(ios.width() == 0); 14968 } 14969 ios.width(25); 14970 internal(ios); 14971 { 14972 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14973 std::string ex(str, iter.base()); 14974 assert(ex == "-******************0x0p+0"); 14975 assert(ios.width() == 0); 14976 } 14977 } 14978 } 14979 showpoint(ios); 14980 { 14981 ios.imbue(lc); 14982 { 14983 ios.width(0); 14984 { 14985 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14986 std::string ex(str, iter.base()); 14987 assert(ex == "-0x0.p+0"); 14988 assert(ios.width() == 0); 14989 } 14990 ios.width(25); 14991 left(ios); 14992 { 14993 iter = f.put(output_iterator<char*>(str), ios, '*', v); 14994 std::string ex(str, iter.base()); 14995 assert(ex == "-0x0.p+0*****************"); 14996 assert(ios.width() == 0); 14997 } 14998 ios.width(25); 14999 right(ios); 15000 { 15001 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15002 std::string ex(str, iter.base()); 15003 assert(ex == "*****************-0x0.p+0"); 15004 assert(ios.width() == 0); 15005 } 15006 ios.width(25); 15007 internal(ios); 15008 { 15009 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15010 std::string ex(str, iter.base()); 15011 assert(ex == "-*****************0x0.p+0"); 15012 assert(ios.width() == 0); 15013 } 15014 } 15015 ios.imbue(lg); 15016 { 15017 ios.width(0); 15018 { 15019 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15020 std::string ex(str, iter.base()); 15021 assert(ex == "-0x0;p+0"); 15022 assert(ios.width() == 0); 15023 } 15024 ios.width(25); 15025 left(ios); 15026 { 15027 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15028 std::string ex(str, iter.base()); 15029 assert(ex == "-0x0;p+0*****************"); 15030 assert(ios.width() == 0); 15031 } 15032 ios.width(25); 15033 right(ios); 15034 { 15035 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15036 std::string ex(str, iter.base()); 15037 assert(ex == "*****************-0x0;p+0"); 15038 assert(ios.width() == 0); 15039 } 15040 ios.width(25); 15041 internal(ios); 15042 { 15043 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15044 std::string ex(str, iter.base()); 15045 assert(ex == "-*****************0x0;p+0"); 15046 assert(ios.width() == 0); 15047 } 15048 } 15049 } 15050 } 15051 showpos(ios); 15052 { 15053 noshowpoint(ios); 15054 { 15055 ios.imbue(lc); 15056 { 15057 ios.width(0); 15058 { 15059 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15060 std::string ex(str, iter.base()); 15061 assert(ex == "-0x0p+0"); 15062 assert(ios.width() == 0); 15063 } 15064 ios.width(25); 15065 left(ios); 15066 { 15067 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15068 std::string ex(str, iter.base()); 15069 assert(ex == "-0x0p+0******************"); 15070 assert(ios.width() == 0); 15071 } 15072 ios.width(25); 15073 right(ios); 15074 { 15075 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15076 std::string ex(str, iter.base()); 15077 assert(ex == "******************-0x0p+0"); 15078 assert(ios.width() == 0); 15079 } 15080 ios.width(25); 15081 internal(ios); 15082 { 15083 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15084 std::string ex(str, iter.base()); 15085 assert(ex == "-******************0x0p+0"); 15086 assert(ios.width() == 0); 15087 } 15088 } 15089 ios.imbue(lg); 15090 { 15091 ios.width(0); 15092 { 15093 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15094 std::string ex(str, iter.base()); 15095 assert(ex == "-0x0p+0"); 15096 assert(ios.width() == 0); 15097 } 15098 ios.width(25); 15099 left(ios); 15100 { 15101 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15102 std::string ex(str, iter.base()); 15103 assert(ex == "-0x0p+0******************"); 15104 assert(ios.width() == 0); 15105 } 15106 ios.width(25); 15107 right(ios); 15108 { 15109 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15110 std::string ex(str, iter.base()); 15111 assert(ex == "******************-0x0p+0"); 15112 assert(ios.width() == 0); 15113 } 15114 ios.width(25); 15115 internal(ios); 15116 { 15117 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15118 std::string ex(str, iter.base()); 15119 assert(ex == "-******************0x0p+0"); 15120 assert(ios.width() == 0); 15121 } 15122 } 15123 } 15124 showpoint(ios); 15125 { 15126 ios.imbue(lc); 15127 { 15128 ios.width(0); 15129 { 15130 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15131 std::string ex(str, iter.base()); 15132 assert(ex == "-0x0.p+0"); 15133 assert(ios.width() == 0); 15134 } 15135 ios.width(25); 15136 left(ios); 15137 { 15138 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15139 std::string ex(str, iter.base()); 15140 assert(ex == "-0x0.p+0*****************"); 15141 assert(ios.width() == 0); 15142 } 15143 ios.width(25); 15144 right(ios); 15145 { 15146 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15147 std::string ex(str, iter.base()); 15148 assert(ex == "*****************-0x0.p+0"); 15149 assert(ios.width() == 0); 15150 } 15151 ios.width(25); 15152 internal(ios); 15153 { 15154 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15155 std::string ex(str, iter.base()); 15156 assert(ex == "-*****************0x0.p+0"); 15157 assert(ios.width() == 0); 15158 } 15159 } 15160 ios.imbue(lg); 15161 { 15162 ios.width(0); 15163 { 15164 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15165 std::string ex(str, iter.base()); 15166 assert(ex == "-0x0;p+0"); 15167 assert(ios.width() == 0); 15168 } 15169 ios.width(25); 15170 left(ios); 15171 { 15172 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15173 std::string ex(str, iter.base()); 15174 assert(ex == "-0x0;p+0*****************"); 15175 assert(ios.width() == 0); 15176 } 15177 ios.width(25); 15178 right(ios); 15179 { 15180 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15181 std::string ex(str, iter.base()); 15182 assert(ex == "*****************-0x0;p+0"); 15183 assert(ios.width() == 0); 15184 } 15185 ios.width(25); 15186 internal(ios); 15187 { 15188 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15189 std::string ex(str, iter.base()); 15190 assert(ex == "-*****************0x0;p+0"); 15191 assert(ios.width() == 0); 15192 } 15193 } 15194 } 15195 } 15196 } 15197 uppercase(ios); 15198 { 15199 noshowpos(ios); 15200 { 15201 noshowpoint(ios); 15202 { 15203 ios.imbue(lc); 15204 { 15205 ios.width(0); 15206 { 15207 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15208 std::string ex(str, iter.base()); 15209 assert(ex == "-0X0P+0"); 15210 assert(ios.width() == 0); 15211 } 15212 ios.width(25); 15213 left(ios); 15214 { 15215 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15216 std::string ex(str, iter.base()); 15217 assert(ex == "-0X0P+0******************"); 15218 assert(ios.width() == 0); 15219 } 15220 ios.width(25); 15221 right(ios); 15222 { 15223 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15224 std::string ex(str, iter.base()); 15225 assert(ex == "******************-0X0P+0"); 15226 assert(ios.width() == 0); 15227 } 15228 ios.width(25); 15229 internal(ios); 15230 { 15231 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15232 std::string ex(str, iter.base()); 15233 assert(ex == "-******************0X0P+0"); 15234 assert(ios.width() == 0); 15235 } 15236 } 15237 ios.imbue(lg); 15238 { 15239 ios.width(0); 15240 { 15241 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15242 std::string ex(str, iter.base()); 15243 assert(ex == "-0X0P+0"); 15244 assert(ios.width() == 0); 15245 } 15246 ios.width(25); 15247 left(ios); 15248 { 15249 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15250 std::string ex(str, iter.base()); 15251 assert(ex == "-0X0P+0******************"); 15252 assert(ios.width() == 0); 15253 } 15254 ios.width(25); 15255 right(ios); 15256 { 15257 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15258 std::string ex(str, iter.base()); 15259 assert(ex == "******************-0X0P+0"); 15260 assert(ios.width() == 0); 15261 } 15262 ios.width(25); 15263 internal(ios); 15264 { 15265 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15266 std::string ex(str, iter.base()); 15267 assert(ex == "-******************0X0P+0"); 15268 assert(ios.width() == 0); 15269 } 15270 } 15271 } 15272 showpoint(ios); 15273 { 15274 ios.imbue(lc); 15275 { 15276 ios.width(0); 15277 { 15278 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15279 std::string ex(str, iter.base()); 15280 assert(ex == "-0X0.P+0"); 15281 assert(ios.width() == 0); 15282 } 15283 ios.width(25); 15284 left(ios); 15285 { 15286 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15287 std::string ex(str, iter.base()); 15288 assert(ex == "-0X0.P+0*****************"); 15289 assert(ios.width() == 0); 15290 } 15291 ios.width(25); 15292 right(ios); 15293 { 15294 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15295 std::string ex(str, iter.base()); 15296 assert(ex == "*****************-0X0.P+0"); 15297 assert(ios.width() == 0); 15298 } 15299 ios.width(25); 15300 internal(ios); 15301 { 15302 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15303 std::string ex(str, iter.base()); 15304 assert(ex == "-*****************0X0.P+0"); 15305 assert(ios.width() == 0); 15306 } 15307 } 15308 ios.imbue(lg); 15309 { 15310 ios.width(0); 15311 { 15312 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15313 std::string ex(str, iter.base()); 15314 assert(ex == "-0X0;P+0"); 15315 assert(ios.width() == 0); 15316 } 15317 ios.width(25); 15318 left(ios); 15319 { 15320 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15321 std::string ex(str, iter.base()); 15322 assert(ex == "-0X0;P+0*****************"); 15323 assert(ios.width() == 0); 15324 } 15325 ios.width(25); 15326 right(ios); 15327 { 15328 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15329 std::string ex(str, iter.base()); 15330 assert(ex == "*****************-0X0;P+0"); 15331 assert(ios.width() == 0); 15332 } 15333 ios.width(25); 15334 internal(ios); 15335 { 15336 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15337 std::string ex(str, iter.base()); 15338 assert(ex == "-*****************0X0;P+0"); 15339 assert(ios.width() == 0); 15340 } 15341 } 15342 } 15343 } 15344 showpos(ios); 15345 { 15346 noshowpoint(ios); 15347 { 15348 ios.imbue(lc); 15349 { 15350 ios.width(0); 15351 { 15352 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15353 std::string ex(str, iter.base()); 15354 assert(ex == "-0X0P+0"); 15355 assert(ios.width() == 0); 15356 } 15357 ios.width(25); 15358 left(ios); 15359 { 15360 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15361 std::string ex(str, iter.base()); 15362 assert(ex == "-0X0P+0******************"); 15363 assert(ios.width() == 0); 15364 } 15365 ios.width(25); 15366 right(ios); 15367 { 15368 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15369 std::string ex(str, iter.base()); 15370 assert(ex == "******************-0X0P+0"); 15371 assert(ios.width() == 0); 15372 } 15373 ios.width(25); 15374 internal(ios); 15375 { 15376 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15377 std::string ex(str, iter.base()); 15378 assert(ex == "-******************0X0P+0"); 15379 assert(ios.width() == 0); 15380 } 15381 } 15382 ios.imbue(lg); 15383 { 15384 ios.width(0); 15385 { 15386 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15387 std::string ex(str, iter.base()); 15388 assert(ex == "-0X0P+0"); 15389 assert(ios.width() == 0); 15390 } 15391 ios.width(25); 15392 left(ios); 15393 { 15394 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15395 std::string ex(str, iter.base()); 15396 assert(ex == "-0X0P+0******************"); 15397 assert(ios.width() == 0); 15398 } 15399 ios.width(25); 15400 right(ios); 15401 { 15402 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15403 std::string ex(str, iter.base()); 15404 assert(ex == "******************-0X0P+0"); 15405 assert(ios.width() == 0); 15406 } 15407 ios.width(25); 15408 internal(ios); 15409 { 15410 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15411 std::string ex(str, iter.base()); 15412 assert(ex == "-******************0X0P+0"); 15413 assert(ios.width() == 0); 15414 } 15415 } 15416 } 15417 showpoint(ios); 15418 { 15419 ios.imbue(lc); 15420 { 15421 ios.width(0); 15422 { 15423 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15424 std::string ex(str, iter.base()); 15425 assert(ex == "-0X0.P+0"); 15426 assert(ios.width() == 0); 15427 } 15428 ios.width(25); 15429 left(ios); 15430 { 15431 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15432 std::string ex(str, iter.base()); 15433 assert(ex == "-0X0.P+0*****************"); 15434 assert(ios.width() == 0); 15435 } 15436 ios.width(25); 15437 right(ios); 15438 { 15439 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15440 std::string ex(str, iter.base()); 15441 assert(ex == "*****************-0X0.P+0"); 15442 assert(ios.width() == 0); 15443 } 15444 ios.width(25); 15445 internal(ios); 15446 { 15447 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15448 std::string ex(str, iter.base()); 15449 assert(ex == "-*****************0X0.P+0"); 15450 assert(ios.width() == 0); 15451 } 15452 } 15453 ios.imbue(lg); 15454 { 15455 ios.width(0); 15456 { 15457 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15458 std::string ex(str, iter.base()); 15459 assert(ex == "-0X0;P+0"); 15460 assert(ios.width() == 0); 15461 } 15462 ios.width(25); 15463 left(ios); 15464 { 15465 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15466 std::string ex(str, iter.base()); 15467 assert(ex == "-0X0;P+0*****************"); 15468 assert(ios.width() == 0); 15469 } 15470 ios.width(25); 15471 right(ios); 15472 { 15473 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15474 std::string ex(str, iter.base()); 15475 assert(ex == "*****************-0X0;P+0"); 15476 assert(ios.width() == 0); 15477 } 15478 ios.width(25); 15479 internal(ios); 15480 { 15481 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15482 std::string ex(str, iter.base()); 15483 assert(ex == "-*****************0X0;P+0"); 15484 assert(ios.width() == 0); 15485 } 15486 } 15487 } 15488 } 15489 } 15490 } 15491 ios.precision(6); 15492 { 15493 nouppercase(ios); 15494 { 15495 noshowpos(ios); 15496 { 15497 noshowpoint(ios); 15498 { 15499 ios.imbue(lc); 15500 { 15501 ios.width(0); 15502 { 15503 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15504 std::string ex(str, iter.base()); 15505 assert(ex == "-0x0p+0"); 15506 assert(ios.width() == 0); 15507 } 15508 ios.width(25); 15509 left(ios); 15510 { 15511 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15512 std::string ex(str, iter.base()); 15513 assert(ex == "-0x0p+0******************"); 15514 assert(ios.width() == 0); 15515 } 15516 ios.width(25); 15517 right(ios); 15518 { 15519 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15520 std::string ex(str, iter.base()); 15521 assert(ex == "******************-0x0p+0"); 15522 assert(ios.width() == 0); 15523 } 15524 ios.width(25); 15525 internal(ios); 15526 { 15527 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15528 std::string ex(str, iter.base()); 15529 assert(ex == "-******************0x0p+0"); 15530 assert(ios.width() == 0); 15531 } 15532 } 15533 ios.imbue(lg); 15534 { 15535 ios.width(0); 15536 { 15537 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15538 std::string ex(str, iter.base()); 15539 assert(ex == "-0x0p+0"); 15540 assert(ios.width() == 0); 15541 } 15542 ios.width(25); 15543 left(ios); 15544 { 15545 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15546 std::string ex(str, iter.base()); 15547 assert(ex == "-0x0p+0******************"); 15548 assert(ios.width() == 0); 15549 } 15550 ios.width(25); 15551 right(ios); 15552 { 15553 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15554 std::string ex(str, iter.base()); 15555 assert(ex == "******************-0x0p+0"); 15556 assert(ios.width() == 0); 15557 } 15558 ios.width(25); 15559 internal(ios); 15560 { 15561 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15562 std::string ex(str, iter.base()); 15563 assert(ex == "-******************0x0p+0"); 15564 assert(ios.width() == 0); 15565 } 15566 } 15567 } 15568 showpoint(ios); 15569 { 15570 ios.imbue(lc); 15571 { 15572 ios.width(0); 15573 { 15574 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15575 std::string ex(str, iter.base()); 15576 assert(ex == "-0x0.p+0"); 15577 assert(ios.width() == 0); 15578 } 15579 ios.width(25); 15580 left(ios); 15581 { 15582 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15583 std::string ex(str, iter.base()); 15584 assert(ex == "-0x0.p+0*****************"); 15585 assert(ios.width() == 0); 15586 } 15587 ios.width(25); 15588 right(ios); 15589 { 15590 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15591 std::string ex(str, iter.base()); 15592 assert(ex == "*****************-0x0.p+0"); 15593 assert(ios.width() == 0); 15594 } 15595 ios.width(25); 15596 internal(ios); 15597 { 15598 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15599 std::string ex(str, iter.base()); 15600 assert(ex == "-*****************0x0.p+0"); 15601 assert(ios.width() == 0); 15602 } 15603 } 15604 ios.imbue(lg); 15605 { 15606 ios.width(0); 15607 { 15608 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15609 std::string ex(str, iter.base()); 15610 assert(ex == "-0x0;p+0"); 15611 assert(ios.width() == 0); 15612 } 15613 ios.width(25); 15614 left(ios); 15615 { 15616 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15617 std::string ex(str, iter.base()); 15618 assert(ex == "-0x0;p+0*****************"); 15619 assert(ios.width() == 0); 15620 } 15621 ios.width(25); 15622 right(ios); 15623 { 15624 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15625 std::string ex(str, iter.base()); 15626 assert(ex == "*****************-0x0;p+0"); 15627 assert(ios.width() == 0); 15628 } 15629 ios.width(25); 15630 internal(ios); 15631 { 15632 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15633 std::string ex(str, iter.base()); 15634 assert(ex == "-*****************0x0;p+0"); 15635 assert(ios.width() == 0); 15636 } 15637 } 15638 } 15639 } 15640 showpos(ios); 15641 { 15642 noshowpoint(ios); 15643 { 15644 ios.imbue(lc); 15645 { 15646 ios.width(0); 15647 { 15648 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15649 std::string ex(str, iter.base()); 15650 assert(ex == "-0x0p+0"); 15651 assert(ios.width() == 0); 15652 } 15653 ios.width(25); 15654 left(ios); 15655 { 15656 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15657 std::string ex(str, iter.base()); 15658 assert(ex == "-0x0p+0******************"); 15659 assert(ios.width() == 0); 15660 } 15661 ios.width(25); 15662 right(ios); 15663 { 15664 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15665 std::string ex(str, iter.base()); 15666 assert(ex == "******************-0x0p+0"); 15667 assert(ios.width() == 0); 15668 } 15669 ios.width(25); 15670 internal(ios); 15671 { 15672 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15673 std::string ex(str, iter.base()); 15674 assert(ex == "-******************0x0p+0"); 15675 assert(ios.width() == 0); 15676 } 15677 } 15678 ios.imbue(lg); 15679 { 15680 ios.width(0); 15681 { 15682 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15683 std::string ex(str, iter.base()); 15684 assert(ex == "-0x0p+0"); 15685 assert(ios.width() == 0); 15686 } 15687 ios.width(25); 15688 left(ios); 15689 { 15690 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15691 std::string ex(str, iter.base()); 15692 assert(ex == "-0x0p+0******************"); 15693 assert(ios.width() == 0); 15694 } 15695 ios.width(25); 15696 right(ios); 15697 { 15698 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15699 std::string ex(str, iter.base()); 15700 assert(ex == "******************-0x0p+0"); 15701 assert(ios.width() == 0); 15702 } 15703 ios.width(25); 15704 internal(ios); 15705 { 15706 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15707 std::string ex(str, iter.base()); 15708 assert(ex == "-******************0x0p+0"); 15709 assert(ios.width() == 0); 15710 } 15711 } 15712 } 15713 showpoint(ios); 15714 { 15715 ios.imbue(lc); 15716 { 15717 ios.width(0); 15718 { 15719 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15720 std::string ex(str, iter.base()); 15721 assert(ex == "-0x0.p+0"); 15722 assert(ios.width() == 0); 15723 } 15724 ios.width(25); 15725 left(ios); 15726 { 15727 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15728 std::string ex(str, iter.base()); 15729 assert(ex == "-0x0.p+0*****************"); 15730 assert(ios.width() == 0); 15731 } 15732 ios.width(25); 15733 right(ios); 15734 { 15735 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15736 std::string ex(str, iter.base()); 15737 assert(ex == "*****************-0x0.p+0"); 15738 assert(ios.width() == 0); 15739 } 15740 ios.width(25); 15741 internal(ios); 15742 { 15743 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15744 std::string ex(str, iter.base()); 15745 assert(ex == "-*****************0x0.p+0"); 15746 assert(ios.width() == 0); 15747 } 15748 } 15749 ios.imbue(lg); 15750 { 15751 ios.width(0); 15752 { 15753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15754 std::string ex(str, iter.base()); 15755 assert(ex == "-0x0;p+0"); 15756 assert(ios.width() == 0); 15757 } 15758 ios.width(25); 15759 left(ios); 15760 { 15761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15762 std::string ex(str, iter.base()); 15763 assert(ex == "-0x0;p+0*****************"); 15764 assert(ios.width() == 0); 15765 } 15766 ios.width(25); 15767 right(ios); 15768 { 15769 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15770 std::string ex(str, iter.base()); 15771 assert(ex == "*****************-0x0;p+0"); 15772 assert(ios.width() == 0); 15773 } 15774 ios.width(25); 15775 internal(ios); 15776 { 15777 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15778 std::string ex(str, iter.base()); 15779 assert(ex == "-*****************0x0;p+0"); 15780 assert(ios.width() == 0); 15781 } 15782 } 15783 } 15784 } 15785 } 15786 uppercase(ios); 15787 { 15788 noshowpos(ios); 15789 { 15790 noshowpoint(ios); 15791 { 15792 ios.imbue(lc); 15793 { 15794 ios.width(0); 15795 { 15796 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15797 std::string ex(str, iter.base()); 15798 assert(ex == "-0X0P+0"); 15799 assert(ios.width() == 0); 15800 } 15801 ios.width(25); 15802 left(ios); 15803 { 15804 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15805 std::string ex(str, iter.base()); 15806 assert(ex == "-0X0P+0******************"); 15807 assert(ios.width() == 0); 15808 } 15809 ios.width(25); 15810 right(ios); 15811 { 15812 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15813 std::string ex(str, iter.base()); 15814 assert(ex == "******************-0X0P+0"); 15815 assert(ios.width() == 0); 15816 } 15817 ios.width(25); 15818 internal(ios); 15819 { 15820 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15821 std::string ex(str, iter.base()); 15822 assert(ex == "-******************0X0P+0"); 15823 assert(ios.width() == 0); 15824 } 15825 } 15826 ios.imbue(lg); 15827 { 15828 ios.width(0); 15829 { 15830 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15831 std::string ex(str, iter.base()); 15832 assert(ex == "-0X0P+0"); 15833 assert(ios.width() == 0); 15834 } 15835 ios.width(25); 15836 left(ios); 15837 { 15838 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15839 std::string ex(str, iter.base()); 15840 assert(ex == "-0X0P+0******************"); 15841 assert(ios.width() == 0); 15842 } 15843 ios.width(25); 15844 right(ios); 15845 { 15846 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15847 std::string ex(str, iter.base()); 15848 assert(ex == "******************-0X0P+0"); 15849 assert(ios.width() == 0); 15850 } 15851 ios.width(25); 15852 internal(ios); 15853 { 15854 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15855 std::string ex(str, iter.base()); 15856 assert(ex == "-******************0X0P+0"); 15857 assert(ios.width() == 0); 15858 } 15859 } 15860 } 15861 showpoint(ios); 15862 { 15863 ios.imbue(lc); 15864 { 15865 ios.width(0); 15866 { 15867 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15868 std::string ex(str, iter.base()); 15869 assert(ex == "-0X0.P+0"); 15870 assert(ios.width() == 0); 15871 } 15872 ios.width(25); 15873 left(ios); 15874 { 15875 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15876 std::string ex(str, iter.base()); 15877 assert(ex == "-0X0.P+0*****************"); 15878 assert(ios.width() == 0); 15879 } 15880 ios.width(25); 15881 right(ios); 15882 { 15883 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15884 std::string ex(str, iter.base()); 15885 assert(ex == "*****************-0X0.P+0"); 15886 assert(ios.width() == 0); 15887 } 15888 ios.width(25); 15889 internal(ios); 15890 { 15891 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15892 std::string ex(str, iter.base()); 15893 assert(ex == "-*****************0X0.P+0"); 15894 assert(ios.width() == 0); 15895 } 15896 } 15897 ios.imbue(lg); 15898 { 15899 ios.width(0); 15900 { 15901 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15902 std::string ex(str, iter.base()); 15903 assert(ex == "-0X0;P+0"); 15904 assert(ios.width() == 0); 15905 } 15906 ios.width(25); 15907 left(ios); 15908 { 15909 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15910 std::string ex(str, iter.base()); 15911 assert(ex == "-0X0;P+0*****************"); 15912 assert(ios.width() == 0); 15913 } 15914 ios.width(25); 15915 right(ios); 15916 { 15917 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15918 std::string ex(str, iter.base()); 15919 assert(ex == "*****************-0X0;P+0"); 15920 assert(ios.width() == 0); 15921 } 15922 ios.width(25); 15923 internal(ios); 15924 { 15925 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15926 std::string ex(str, iter.base()); 15927 assert(ex == "-*****************0X0;P+0"); 15928 assert(ios.width() == 0); 15929 } 15930 } 15931 } 15932 } 15933 showpos(ios); 15934 { 15935 noshowpoint(ios); 15936 { 15937 ios.imbue(lc); 15938 { 15939 ios.width(0); 15940 { 15941 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15942 std::string ex(str, iter.base()); 15943 assert(ex == "-0X0P+0"); 15944 assert(ios.width() == 0); 15945 } 15946 ios.width(25); 15947 left(ios); 15948 { 15949 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15950 std::string ex(str, iter.base()); 15951 assert(ex == "-0X0P+0******************"); 15952 assert(ios.width() == 0); 15953 } 15954 ios.width(25); 15955 right(ios); 15956 { 15957 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15958 std::string ex(str, iter.base()); 15959 assert(ex == "******************-0X0P+0"); 15960 assert(ios.width() == 0); 15961 } 15962 ios.width(25); 15963 internal(ios); 15964 { 15965 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15966 std::string ex(str, iter.base()); 15967 assert(ex == "-******************0X0P+0"); 15968 assert(ios.width() == 0); 15969 } 15970 } 15971 ios.imbue(lg); 15972 { 15973 ios.width(0); 15974 { 15975 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15976 std::string ex(str, iter.base()); 15977 assert(ex == "-0X0P+0"); 15978 assert(ios.width() == 0); 15979 } 15980 ios.width(25); 15981 left(ios); 15982 { 15983 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15984 std::string ex(str, iter.base()); 15985 assert(ex == "-0X0P+0******************"); 15986 assert(ios.width() == 0); 15987 } 15988 ios.width(25); 15989 right(ios); 15990 { 15991 iter = f.put(output_iterator<char*>(str), ios, '*', v); 15992 std::string ex(str, iter.base()); 15993 assert(ex == "******************-0X0P+0"); 15994 assert(ios.width() == 0); 15995 } 15996 ios.width(25); 15997 internal(ios); 15998 { 15999 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16000 std::string ex(str, iter.base()); 16001 assert(ex == "-******************0X0P+0"); 16002 assert(ios.width() == 0); 16003 } 16004 } 16005 } 16006 showpoint(ios); 16007 { 16008 ios.imbue(lc); 16009 { 16010 ios.width(0); 16011 { 16012 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16013 std::string ex(str, iter.base()); 16014 assert(ex == "-0X0.P+0"); 16015 assert(ios.width() == 0); 16016 } 16017 ios.width(25); 16018 left(ios); 16019 { 16020 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16021 std::string ex(str, iter.base()); 16022 assert(ex == "-0X0.P+0*****************"); 16023 assert(ios.width() == 0); 16024 } 16025 ios.width(25); 16026 right(ios); 16027 { 16028 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16029 std::string ex(str, iter.base()); 16030 assert(ex == "*****************-0X0.P+0"); 16031 assert(ios.width() == 0); 16032 } 16033 ios.width(25); 16034 internal(ios); 16035 { 16036 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16037 std::string ex(str, iter.base()); 16038 assert(ex == "-*****************0X0.P+0"); 16039 assert(ios.width() == 0); 16040 } 16041 } 16042 ios.imbue(lg); 16043 { 16044 ios.width(0); 16045 { 16046 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16047 std::string ex(str, iter.base()); 16048 assert(ex == "-0X0;P+0"); 16049 assert(ios.width() == 0); 16050 } 16051 ios.width(25); 16052 left(ios); 16053 { 16054 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16055 std::string ex(str, iter.base()); 16056 assert(ex == "-0X0;P+0*****************"); 16057 assert(ios.width() == 0); 16058 } 16059 ios.width(25); 16060 right(ios); 16061 { 16062 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16063 std::string ex(str, iter.base()); 16064 assert(ex == "*****************-0X0;P+0"); 16065 assert(ios.width() == 0); 16066 } 16067 ios.width(25); 16068 internal(ios); 16069 { 16070 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16071 std::string ex(str, iter.base()); 16072 assert(ex == "-*****************0X0;P+0"); 16073 assert(ios.width() == 0); 16074 } 16075 } 16076 } 16077 } 16078 } 16079 } 16080 ios.precision(16); 16081 { 16082 } 16083 ios.precision(60); 16084 { 16085 } 16086 } 16087 } 16088 } 16089 16090 void test8() 16091 { 16092 char str[200]; 16093 output_iterator<char*> iter; 16094 std::locale lc = std::locale::classic(); 16095 std::locale lg(lc, new my_numpunct); 16096 const my_facet f(1); 16097 { 16098 double v = 1234567890.125; 16099 std::ios ios(0); 16100 hexfloat(ios); 16101 // %a 16102 { 16103 ios.precision(0); 16104 { 16105 nouppercase(ios); 16106 { 16107 noshowpos(ios); 16108 { 16109 noshowpoint(ios); 16110 { 16111 ios.imbue(lc); 16112 { 16113 ios.width(0); 16114 { 16115 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16116 std::string ex(str, iter.base()); 16117 assert(ex == "0x1.26580b488p+30"); 16118 assert(ios.width() == 0); 16119 } 16120 ios.width(25); 16121 left(ios); 16122 { 16123 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16124 std::string ex(str, iter.base()); 16125 assert(ex == "0x1.26580b488p+30********"); 16126 assert(ios.width() == 0); 16127 } 16128 ios.width(25); 16129 right(ios); 16130 { 16131 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16132 std::string ex(str, iter.base()); 16133 assert(ex == "********0x1.26580b488p+30"); 16134 assert(ios.width() == 0); 16135 } 16136 ios.width(25); 16137 internal(ios); 16138 { 16139 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16140 std::string ex(str, iter.base()); 16141 assert(ex == "0x********1.26580b488p+30"); 16142 assert(ios.width() == 0); 16143 } 16144 } 16145 ios.imbue(lg); 16146 { 16147 ios.width(0); 16148 { 16149 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16150 std::string ex(str, iter.base()); 16151 assert(ex == "0x1;26580b488p+30"); 16152 assert(ios.width() == 0); 16153 } 16154 ios.width(25); 16155 left(ios); 16156 { 16157 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16158 std::string ex(str, iter.base()); 16159 assert(ex == "0x1;26580b488p+30********"); 16160 assert(ios.width() == 0); 16161 } 16162 ios.width(25); 16163 right(ios); 16164 { 16165 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16166 std::string ex(str, iter.base()); 16167 assert(ex == "********0x1;26580b488p+30"); 16168 assert(ios.width() == 0); 16169 } 16170 ios.width(25); 16171 internal(ios); 16172 { 16173 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16174 std::string ex(str, iter.base()); 16175 assert(ex == "0x********1;26580b488p+30"); 16176 assert(ios.width() == 0); 16177 } 16178 } 16179 } 16180 showpoint(ios); 16181 { 16182 ios.imbue(lc); 16183 { 16184 ios.width(0); 16185 { 16186 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16187 std::string ex(str, iter.base()); 16188 assert(ex == "0x1.26580b488p+30"); 16189 assert(ios.width() == 0); 16190 } 16191 ios.width(25); 16192 left(ios); 16193 { 16194 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16195 std::string ex(str, iter.base()); 16196 assert(ex == "0x1.26580b488p+30********"); 16197 assert(ios.width() == 0); 16198 } 16199 ios.width(25); 16200 right(ios); 16201 { 16202 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16203 std::string ex(str, iter.base()); 16204 assert(ex == "********0x1.26580b488p+30"); 16205 assert(ios.width() == 0); 16206 } 16207 ios.width(25); 16208 internal(ios); 16209 { 16210 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16211 std::string ex(str, iter.base()); 16212 assert(ex == "0x********1.26580b488p+30"); 16213 assert(ios.width() == 0); 16214 } 16215 } 16216 ios.imbue(lg); 16217 { 16218 ios.width(0); 16219 { 16220 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16221 std::string ex(str, iter.base()); 16222 assert(ex == "0x1;26580b488p+30"); 16223 assert(ios.width() == 0); 16224 } 16225 ios.width(25); 16226 left(ios); 16227 { 16228 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16229 std::string ex(str, iter.base()); 16230 assert(ex == "0x1;26580b488p+30********"); 16231 assert(ios.width() == 0); 16232 } 16233 ios.width(25); 16234 right(ios); 16235 { 16236 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16237 std::string ex(str, iter.base()); 16238 assert(ex == "********0x1;26580b488p+30"); 16239 assert(ios.width() == 0); 16240 } 16241 ios.width(25); 16242 internal(ios); 16243 { 16244 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16245 std::string ex(str, iter.base()); 16246 assert(ex == "0x********1;26580b488p+30"); 16247 assert(ios.width() == 0); 16248 } 16249 } 16250 } 16251 } 16252 showpos(ios); 16253 { 16254 noshowpoint(ios); 16255 { 16256 ios.imbue(lc); 16257 { 16258 ios.width(0); 16259 { 16260 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16261 std::string ex(str, iter.base()); 16262 assert(ex == "+0x1.26580b488p+30"); 16263 assert(ios.width() == 0); 16264 } 16265 ios.width(25); 16266 left(ios); 16267 { 16268 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16269 std::string ex(str, iter.base()); 16270 assert(ex == "+0x1.26580b488p+30*******"); 16271 assert(ios.width() == 0); 16272 } 16273 ios.width(25); 16274 right(ios); 16275 { 16276 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16277 std::string ex(str, iter.base()); 16278 assert(ex == "*******+0x1.26580b488p+30"); 16279 assert(ios.width() == 0); 16280 } 16281 ios.width(25); 16282 internal(ios); 16283 { 16284 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16285 std::string ex(str, iter.base()); 16286 assert(ex == "+*******0x1.26580b488p+30"); 16287 assert(ios.width() == 0); 16288 } 16289 } 16290 ios.imbue(lg); 16291 { 16292 ios.width(0); 16293 { 16294 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16295 std::string ex(str, iter.base()); 16296 assert(ex == "+0x1;26580b488p+30"); 16297 assert(ios.width() == 0); 16298 } 16299 ios.width(25); 16300 left(ios); 16301 { 16302 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16303 std::string ex(str, iter.base()); 16304 assert(ex == "+0x1;26580b488p+30*******"); 16305 assert(ios.width() == 0); 16306 } 16307 ios.width(25); 16308 right(ios); 16309 { 16310 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16311 std::string ex(str, iter.base()); 16312 assert(ex == "*******+0x1;26580b488p+30"); 16313 assert(ios.width() == 0); 16314 } 16315 ios.width(25); 16316 internal(ios); 16317 { 16318 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16319 std::string ex(str, iter.base()); 16320 assert(ex == "+*******0x1;26580b488p+30"); 16321 assert(ios.width() == 0); 16322 } 16323 } 16324 } 16325 showpoint(ios); 16326 { 16327 ios.imbue(lc); 16328 { 16329 ios.width(0); 16330 { 16331 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16332 std::string ex(str, iter.base()); 16333 assert(ex == "+0x1.26580b488p+30"); 16334 assert(ios.width() == 0); 16335 } 16336 ios.width(25); 16337 left(ios); 16338 { 16339 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16340 std::string ex(str, iter.base()); 16341 assert(ex == "+0x1.26580b488p+30*******"); 16342 assert(ios.width() == 0); 16343 } 16344 ios.width(25); 16345 right(ios); 16346 { 16347 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16348 std::string ex(str, iter.base()); 16349 assert(ex == "*******+0x1.26580b488p+30"); 16350 assert(ios.width() == 0); 16351 } 16352 ios.width(25); 16353 internal(ios); 16354 { 16355 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16356 std::string ex(str, iter.base()); 16357 assert(ex == "+*******0x1.26580b488p+30"); 16358 assert(ios.width() == 0); 16359 } 16360 } 16361 ios.imbue(lg); 16362 { 16363 ios.width(0); 16364 { 16365 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16366 std::string ex(str, iter.base()); 16367 assert(ex == "+0x1;26580b488p+30"); 16368 assert(ios.width() == 0); 16369 } 16370 ios.width(25); 16371 left(ios); 16372 { 16373 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16374 std::string ex(str, iter.base()); 16375 assert(ex == "+0x1;26580b488p+30*******"); 16376 assert(ios.width() == 0); 16377 } 16378 ios.width(25); 16379 right(ios); 16380 { 16381 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16382 std::string ex(str, iter.base()); 16383 assert(ex == "*******+0x1;26580b488p+30"); 16384 assert(ios.width() == 0); 16385 } 16386 ios.width(25); 16387 internal(ios); 16388 { 16389 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16390 std::string ex(str, iter.base()); 16391 assert(ex == "+*******0x1;26580b488p+30"); 16392 assert(ios.width() == 0); 16393 } 16394 } 16395 } 16396 } 16397 } 16398 uppercase(ios); 16399 { 16400 noshowpos(ios); 16401 { 16402 noshowpoint(ios); 16403 { 16404 ios.imbue(lc); 16405 { 16406 ios.width(0); 16407 { 16408 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16409 std::string ex(str, iter.base()); 16410 assert(ex == "0X1.26580B488P+30"); 16411 assert(ios.width() == 0); 16412 } 16413 ios.width(25); 16414 left(ios); 16415 { 16416 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16417 std::string ex(str, iter.base()); 16418 assert(ex == "0X1.26580B488P+30********"); 16419 assert(ios.width() == 0); 16420 } 16421 ios.width(25); 16422 right(ios); 16423 { 16424 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16425 std::string ex(str, iter.base()); 16426 assert(ex == "********0X1.26580B488P+30"); 16427 assert(ios.width() == 0); 16428 } 16429 ios.width(25); 16430 internal(ios); 16431 { 16432 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16433 std::string ex(str, iter.base()); 16434 assert(ex == "0X********1.26580B488P+30"); 16435 assert(ios.width() == 0); 16436 } 16437 } 16438 ios.imbue(lg); 16439 { 16440 ios.width(0); 16441 { 16442 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16443 std::string ex(str, iter.base()); 16444 assert(ex == "0X1;26580B488P+30"); 16445 assert(ios.width() == 0); 16446 } 16447 ios.width(25); 16448 left(ios); 16449 { 16450 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16451 std::string ex(str, iter.base()); 16452 assert(ex == "0X1;26580B488P+30********"); 16453 assert(ios.width() == 0); 16454 } 16455 ios.width(25); 16456 right(ios); 16457 { 16458 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16459 std::string ex(str, iter.base()); 16460 assert(ex == "********0X1;26580B488P+30"); 16461 assert(ios.width() == 0); 16462 } 16463 ios.width(25); 16464 internal(ios); 16465 { 16466 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16467 std::string ex(str, iter.base()); 16468 assert(ex == "0X********1;26580B488P+30"); 16469 assert(ios.width() == 0); 16470 } 16471 } 16472 } 16473 showpoint(ios); 16474 { 16475 ios.imbue(lc); 16476 { 16477 ios.width(0); 16478 { 16479 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16480 std::string ex(str, iter.base()); 16481 assert(ex == "0X1.26580B488P+30"); 16482 assert(ios.width() == 0); 16483 } 16484 ios.width(25); 16485 left(ios); 16486 { 16487 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16488 std::string ex(str, iter.base()); 16489 assert(ex == "0X1.26580B488P+30********"); 16490 assert(ios.width() == 0); 16491 } 16492 ios.width(25); 16493 right(ios); 16494 { 16495 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16496 std::string ex(str, iter.base()); 16497 assert(ex == "********0X1.26580B488P+30"); 16498 assert(ios.width() == 0); 16499 } 16500 ios.width(25); 16501 internal(ios); 16502 { 16503 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16504 std::string ex(str, iter.base()); 16505 assert(ex == "0X********1.26580B488P+30"); 16506 assert(ios.width() == 0); 16507 } 16508 } 16509 ios.imbue(lg); 16510 { 16511 ios.width(0); 16512 { 16513 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16514 std::string ex(str, iter.base()); 16515 assert(ex == "0X1;26580B488P+30"); 16516 assert(ios.width() == 0); 16517 } 16518 ios.width(25); 16519 left(ios); 16520 { 16521 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16522 std::string ex(str, iter.base()); 16523 assert(ex == "0X1;26580B488P+30********"); 16524 assert(ios.width() == 0); 16525 } 16526 ios.width(25); 16527 right(ios); 16528 { 16529 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16530 std::string ex(str, iter.base()); 16531 assert(ex == "********0X1;26580B488P+30"); 16532 assert(ios.width() == 0); 16533 } 16534 ios.width(25); 16535 internal(ios); 16536 { 16537 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16538 std::string ex(str, iter.base()); 16539 assert(ex == "0X********1;26580B488P+30"); 16540 assert(ios.width() == 0); 16541 } 16542 } 16543 } 16544 } 16545 showpos(ios); 16546 { 16547 noshowpoint(ios); 16548 { 16549 ios.imbue(lc); 16550 { 16551 ios.width(0); 16552 { 16553 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16554 std::string ex(str, iter.base()); 16555 assert(ex == "+0X1.26580B488P+30"); 16556 assert(ios.width() == 0); 16557 } 16558 ios.width(25); 16559 left(ios); 16560 { 16561 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16562 std::string ex(str, iter.base()); 16563 assert(ex == "+0X1.26580B488P+30*******"); 16564 assert(ios.width() == 0); 16565 } 16566 ios.width(25); 16567 right(ios); 16568 { 16569 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16570 std::string ex(str, iter.base()); 16571 assert(ex == "*******+0X1.26580B488P+30"); 16572 assert(ios.width() == 0); 16573 } 16574 ios.width(25); 16575 internal(ios); 16576 { 16577 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16578 std::string ex(str, iter.base()); 16579 assert(ex == "+*******0X1.26580B488P+30"); 16580 assert(ios.width() == 0); 16581 } 16582 } 16583 ios.imbue(lg); 16584 { 16585 ios.width(0); 16586 { 16587 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16588 std::string ex(str, iter.base()); 16589 assert(ex == "+0X1;26580B488P+30"); 16590 assert(ios.width() == 0); 16591 } 16592 ios.width(25); 16593 left(ios); 16594 { 16595 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16596 std::string ex(str, iter.base()); 16597 assert(ex == "+0X1;26580B488P+30*******"); 16598 assert(ios.width() == 0); 16599 } 16600 ios.width(25); 16601 right(ios); 16602 { 16603 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16604 std::string ex(str, iter.base()); 16605 assert(ex == "*******+0X1;26580B488P+30"); 16606 assert(ios.width() == 0); 16607 } 16608 ios.width(25); 16609 internal(ios); 16610 { 16611 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16612 std::string ex(str, iter.base()); 16613 assert(ex == "+*******0X1;26580B488P+30"); 16614 assert(ios.width() == 0); 16615 } 16616 } 16617 } 16618 showpoint(ios); 16619 { 16620 ios.imbue(lc); 16621 { 16622 ios.width(0); 16623 { 16624 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16625 std::string ex(str, iter.base()); 16626 assert(ex == "+0X1.26580B488P+30"); 16627 assert(ios.width() == 0); 16628 } 16629 ios.width(25); 16630 left(ios); 16631 { 16632 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16633 std::string ex(str, iter.base()); 16634 assert(ex == "+0X1.26580B488P+30*******"); 16635 assert(ios.width() == 0); 16636 } 16637 ios.width(25); 16638 right(ios); 16639 { 16640 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16641 std::string ex(str, iter.base()); 16642 assert(ex == "*******+0X1.26580B488P+30"); 16643 assert(ios.width() == 0); 16644 } 16645 ios.width(25); 16646 internal(ios); 16647 { 16648 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16649 std::string ex(str, iter.base()); 16650 assert(ex == "+*******0X1.26580B488P+30"); 16651 assert(ios.width() == 0); 16652 } 16653 } 16654 ios.imbue(lg); 16655 { 16656 ios.width(0); 16657 { 16658 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16659 std::string ex(str, iter.base()); 16660 assert(ex == "+0X1;26580B488P+30"); 16661 assert(ios.width() == 0); 16662 } 16663 ios.width(25); 16664 left(ios); 16665 { 16666 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16667 std::string ex(str, iter.base()); 16668 assert(ex == "+0X1;26580B488P+30*******"); 16669 assert(ios.width() == 0); 16670 } 16671 ios.width(25); 16672 right(ios); 16673 { 16674 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16675 std::string ex(str, iter.base()); 16676 assert(ex == "*******+0X1;26580B488P+30"); 16677 assert(ios.width() == 0); 16678 } 16679 ios.width(25); 16680 internal(ios); 16681 { 16682 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16683 std::string ex(str, iter.base()); 16684 assert(ex == "+*******0X1;26580B488P+30"); 16685 assert(ios.width() == 0); 16686 } 16687 } 16688 } 16689 } 16690 } 16691 } 16692 ios.precision(1); 16693 { 16694 nouppercase(ios); 16695 { 16696 noshowpos(ios); 16697 { 16698 noshowpoint(ios); 16699 { 16700 ios.imbue(lc); 16701 { 16702 ios.width(0); 16703 { 16704 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16705 std::string ex(str, iter.base()); 16706 assert(ex == "0x1.26580b488p+30"); 16707 assert(ios.width() == 0); 16708 } 16709 ios.width(25); 16710 left(ios); 16711 { 16712 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16713 std::string ex(str, iter.base()); 16714 assert(ex == "0x1.26580b488p+30********"); 16715 assert(ios.width() == 0); 16716 } 16717 ios.width(25); 16718 right(ios); 16719 { 16720 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16721 std::string ex(str, iter.base()); 16722 assert(ex == "********0x1.26580b488p+30"); 16723 assert(ios.width() == 0); 16724 } 16725 ios.width(25); 16726 internal(ios); 16727 { 16728 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16729 std::string ex(str, iter.base()); 16730 assert(ex == "0x********1.26580b488p+30"); 16731 assert(ios.width() == 0); 16732 } 16733 } 16734 ios.imbue(lg); 16735 { 16736 ios.width(0); 16737 { 16738 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16739 std::string ex(str, iter.base()); 16740 assert(ex == "0x1;26580b488p+30"); 16741 assert(ios.width() == 0); 16742 } 16743 ios.width(25); 16744 left(ios); 16745 { 16746 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16747 std::string ex(str, iter.base()); 16748 assert(ex == "0x1;26580b488p+30********"); 16749 assert(ios.width() == 0); 16750 } 16751 ios.width(25); 16752 right(ios); 16753 { 16754 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16755 std::string ex(str, iter.base()); 16756 assert(ex == "********0x1;26580b488p+30"); 16757 assert(ios.width() == 0); 16758 } 16759 ios.width(25); 16760 internal(ios); 16761 { 16762 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16763 std::string ex(str, iter.base()); 16764 assert(ex == "0x********1;26580b488p+30"); 16765 assert(ios.width() == 0); 16766 } 16767 } 16768 } 16769 showpoint(ios); 16770 { 16771 ios.imbue(lc); 16772 { 16773 ios.width(0); 16774 { 16775 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16776 std::string ex(str, iter.base()); 16777 assert(ex == "0x1.26580b488p+30"); 16778 assert(ios.width() == 0); 16779 } 16780 ios.width(25); 16781 left(ios); 16782 { 16783 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16784 std::string ex(str, iter.base()); 16785 assert(ex == "0x1.26580b488p+30********"); 16786 assert(ios.width() == 0); 16787 } 16788 ios.width(25); 16789 right(ios); 16790 { 16791 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16792 std::string ex(str, iter.base()); 16793 assert(ex == "********0x1.26580b488p+30"); 16794 assert(ios.width() == 0); 16795 } 16796 ios.width(25); 16797 internal(ios); 16798 { 16799 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16800 std::string ex(str, iter.base()); 16801 assert(ex == "0x********1.26580b488p+30"); 16802 assert(ios.width() == 0); 16803 } 16804 } 16805 ios.imbue(lg); 16806 { 16807 ios.width(0); 16808 { 16809 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16810 std::string ex(str, iter.base()); 16811 assert(ex == "0x1;26580b488p+30"); 16812 assert(ios.width() == 0); 16813 } 16814 ios.width(25); 16815 left(ios); 16816 { 16817 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16818 std::string ex(str, iter.base()); 16819 assert(ex == "0x1;26580b488p+30********"); 16820 assert(ios.width() == 0); 16821 } 16822 ios.width(25); 16823 right(ios); 16824 { 16825 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16826 std::string ex(str, iter.base()); 16827 assert(ex == "********0x1;26580b488p+30"); 16828 assert(ios.width() == 0); 16829 } 16830 ios.width(25); 16831 internal(ios); 16832 { 16833 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16834 std::string ex(str, iter.base()); 16835 assert(ex == "0x********1;26580b488p+30"); 16836 assert(ios.width() == 0); 16837 } 16838 } 16839 } 16840 } 16841 showpos(ios); 16842 { 16843 noshowpoint(ios); 16844 { 16845 ios.imbue(lc); 16846 { 16847 ios.width(0); 16848 { 16849 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16850 std::string ex(str, iter.base()); 16851 assert(ex == "+0x1.26580b488p+30"); 16852 assert(ios.width() == 0); 16853 } 16854 ios.width(25); 16855 left(ios); 16856 { 16857 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16858 std::string ex(str, iter.base()); 16859 assert(ex == "+0x1.26580b488p+30*******"); 16860 assert(ios.width() == 0); 16861 } 16862 ios.width(25); 16863 right(ios); 16864 { 16865 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16866 std::string ex(str, iter.base()); 16867 assert(ex == "*******+0x1.26580b488p+30"); 16868 assert(ios.width() == 0); 16869 } 16870 ios.width(25); 16871 internal(ios); 16872 { 16873 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16874 std::string ex(str, iter.base()); 16875 assert(ex == "+*******0x1.26580b488p+30"); 16876 assert(ios.width() == 0); 16877 } 16878 } 16879 ios.imbue(lg); 16880 { 16881 ios.width(0); 16882 { 16883 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16884 std::string ex(str, iter.base()); 16885 assert(ex == "+0x1;26580b488p+30"); 16886 assert(ios.width() == 0); 16887 } 16888 ios.width(25); 16889 left(ios); 16890 { 16891 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16892 std::string ex(str, iter.base()); 16893 assert(ex == "+0x1;26580b488p+30*******"); 16894 assert(ios.width() == 0); 16895 } 16896 ios.width(25); 16897 right(ios); 16898 { 16899 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16900 std::string ex(str, iter.base()); 16901 assert(ex == "*******+0x1;26580b488p+30"); 16902 assert(ios.width() == 0); 16903 } 16904 ios.width(25); 16905 internal(ios); 16906 { 16907 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16908 std::string ex(str, iter.base()); 16909 assert(ex == "+*******0x1;26580b488p+30"); 16910 assert(ios.width() == 0); 16911 } 16912 } 16913 } 16914 showpoint(ios); 16915 { 16916 ios.imbue(lc); 16917 { 16918 ios.width(0); 16919 { 16920 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16921 std::string ex(str, iter.base()); 16922 assert(ex == "+0x1.26580b488p+30"); 16923 assert(ios.width() == 0); 16924 } 16925 ios.width(25); 16926 left(ios); 16927 { 16928 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16929 std::string ex(str, iter.base()); 16930 assert(ex == "+0x1.26580b488p+30*******"); 16931 assert(ios.width() == 0); 16932 } 16933 ios.width(25); 16934 right(ios); 16935 { 16936 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16937 std::string ex(str, iter.base()); 16938 assert(ex == "*******+0x1.26580b488p+30"); 16939 assert(ios.width() == 0); 16940 } 16941 ios.width(25); 16942 internal(ios); 16943 { 16944 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16945 std::string ex(str, iter.base()); 16946 assert(ex == "+*******0x1.26580b488p+30"); 16947 assert(ios.width() == 0); 16948 } 16949 } 16950 ios.imbue(lg); 16951 { 16952 ios.width(0); 16953 { 16954 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16955 std::string ex(str, iter.base()); 16956 assert(ex == "+0x1;26580b488p+30"); 16957 assert(ios.width() == 0); 16958 } 16959 ios.width(25); 16960 left(ios); 16961 { 16962 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16963 std::string ex(str, iter.base()); 16964 assert(ex == "+0x1;26580b488p+30*******"); 16965 assert(ios.width() == 0); 16966 } 16967 ios.width(25); 16968 right(ios); 16969 { 16970 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16971 std::string ex(str, iter.base()); 16972 assert(ex == "*******+0x1;26580b488p+30"); 16973 assert(ios.width() == 0); 16974 } 16975 ios.width(25); 16976 internal(ios); 16977 { 16978 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16979 std::string ex(str, iter.base()); 16980 assert(ex == "+*******0x1;26580b488p+30"); 16981 assert(ios.width() == 0); 16982 } 16983 } 16984 } 16985 } 16986 } 16987 uppercase(ios); 16988 { 16989 noshowpos(ios); 16990 { 16991 noshowpoint(ios); 16992 { 16993 ios.imbue(lc); 16994 { 16995 ios.width(0); 16996 { 16997 iter = f.put(output_iterator<char*>(str), ios, '*', v); 16998 std::string ex(str, iter.base()); 16999 assert(ex == "0X1.26580B488P+30"); 17000 assert(ios.width() == 0); 17001 } 17002 ios.width(25); 17003 left(ios); 17004 { 17005 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17006 std::string ex(str, iter.base()); 17007 assert(ex == "0X1.26580B488P+30********"); 17008 assert(ios.width() == 0); 17009 } 17010 ios.width(25); 17011 right(ios); 17012 { 17013 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17014 std::string ex(str, iter.base()); 17015 assert(ex == "********0X1.26580B488P+30"); 17016 assert(ios.width() == 0); 17017 } 17018 ios.width(25); 17019 internal(ios); 17020 { 17021 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17022 std::string ex(str, iter.base()); 17023 assert(ex == "0X********1.26580B488P+30"); 17024 assert(ios.width() == 0); 17025 } 17026 } 17027 ios.imbue(lg); 17028 { 17029 ios.width(0); 17030 { 17031 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17032 std::string ex(str, iter.base()); 17033 assert(ex == "0X1;26580B488P+30"); 17034 assert(ios.width() == 0); 17035 } 17036 ios.width(25); 17037 left(ios); 17038 { 17039 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17040 std::string ex(str, iter.base()); 17041 assert(ex == "0X1;26580B488P+30********"); 17042 assert(ios.width() == 0); 17043 } 17044 ios.width(25); 17045 right(ios); 17046 { 17047 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17048 std::string ex(str, iter.base()); 17049 assert(ex == "********0X1;26580B488P+30"); 17050 assert(ios.width() == 0); 17051 } 17052 ios.width(25); 17053 internal(ios); 17054 { 17055 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17056 std::string ex(str, iter.base()); 17057 assert(ex == "0X********1;26580B488P+30"); 17058 assert(ios.width() == 0); 17059 } 17060 } 17061 } 17062 showpoint(ios); 17063 { 17064 ios.imbue(lc); 17065 { 17066 ios.width(0); 17067 { 17068 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17069 std::string ex(str, iter.base()); 17070 assert(ex == "0X1.26580B488P+30"); 17071 assert(ios.width() == 0); 17072 } 17073 ios.width(25); 17074 left(ios); 17075 { 17076 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17077 std::string ex(str, iter.base()); 17078 assert(ex == "0X1.26580B488P+30********"); 17079 assert(ios.width() == 0); 17080 } 17081 ios.width(25); 17082 right(ios); 17083 { 17084 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17085 std::string ex(str, iter.base()); 17086 assert(ex == "********0X1.26580B488P+30"); 17087 assert(ios.width() == 0); 17088 } 17089 ios.width(25); 17090 internal(ios); 17091 { 17092 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17093 std::string ex(str, iter.base()); 17094 assert(ex == "0X********1.26580B488P+30"); 17095 assert(ios.width() == 0); 17096 } 17097 } 17098 ios.imbue(lg); 17099 { 17100 ios.width(0); 17101 { 17102 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17103 std::string ex(str, iter.base()); 17104 assert(ex == "0X1;26580B488P+30"); 17105 assert(ios.width() == 0); 17106 } 17107 ios.width(25); 17108 left(ios); 17109 { 17110 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17111 std::string ex(str, iter.base()); 17112 assert(ex == "0X1;26580B488P+30********"); 17113 assert(ios.width() == 0); 17114 } 17115 ios.width(25); 17116 right(ios); 17117 { 17118 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17119 std::string ex(str, iter.base()); 17120 assert(ex == "********0X1;26580B488P+30"); 17121 assert(ios.width() == 0); 17122 } 17123 ios.width(25); 17124 internal(ios); 17125 { 17126 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17127 std::string ex(str, iter.base()); 17128 assert(ex == "0X********1;26580B488P+30"); 17129 assert(ios.width() == 0); 17130 } 17131 } 17132 } 17133 } 17134 showpos(ios); 17135 { 17136 noshowpoint(ios); 17137 { 17138 ios.imbue(lc); 17139 { 17140 ios.width(0); 17141 { 17142 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17143 std::string ex(str, iter.base()); 17144 assert(ex == "+0X1.26580B488P+30"); 17145 assert(ios.width() == 0); 17146 } 17147 ios.width(25); 17148 left(ios); 17149 { 17150 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17151 std::string ex(str, iter.base()); 17152 assert(ex == "+0X1.26580B488P+30*******"); 17153 assert(ios.width() == 0); 17154 } 17155 ios.width(25); 17156 right(ios); 17157 { 17158 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17159 std::string ex(str, iter.base()); 17160 assert(ex == "*******+0X1.26580B488P+30"); 17161 assert(ios.width() == 0); 17162 } 17163 ios.width(25); 17164 internal(ios); 17165 { 17166 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17167 std::string ex(str, iter.base()); 17168 assert(ex == "+*******0X1.26580B488P+30"); 17169 assert(ios.width() == 0); 17170 } 17171 } 17172 ios.imbue(lg); 17173 { 17174 ios.width(0); 17175 { 17176 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17177 std::string ex(str, iter.base()); 17178 assert(ex == "+0X1;26580B488P+30"); 17179 assert(ios.width() == 0); 17180 } 17181 ios.width(25); 17182 left(ios); 17183 { 17184 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17185 std::string ex(str, iter.base()); 17186 assert(ex == "+0X1;26580B488P+30*******"); 17187 assert(ios.width() == 0); 17188 } 17189 ios.width(25); 17190 right(ios); 17191 { 17192 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17193 std::string ex(str, iter.base()); 17194 assert(ex == "*******+0X1;26580B488P+30"); 17195 assert(ios.width() == 0); 17196 } 17197 ios.width(25); 17198 internal(ios); 17199 { 17200 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17201 std::string ex(str, iter.base()); 17202 assert(ex == "+*******0X1;26580B488P+30"); 17203 assert(ios.width() == 0); 17204 } 17205 } 17206 } 17207 showpoint(ios); 17208 { 17209 ios.imbue(lc); 17210 { 17211 ios.width(0); 17212 { 17213 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17214 std::string ex(str, iter.base()); 17215 assert(ex == "+0X1.26580B488P+30"); 17216 assert(ios.width() == 0); 17217 } 17218 ios.width(25); 17219 left(ios); 17220 { 17221 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17222 std::string ex(str, iter.base()); 17223 assert(ex == "+0X1.26580B488P+30*******"); 17224 assert(ios.width() == 0); 17225 } 17226 ios.width(25); 17227 right(ios); 17228 { 17229 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17230 std::string ex(str, iter.base()); 17231 assert(ex == "*******+0X1.26580B488P+30"); 17232 assert(ios.width() == 0); 17233 } 17234 ios.width(25); 17235 internal(ios); 17236 { 17237 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17238 std::string ex(str, iter.base()); 17239 assert(ex == "+*******0X1.26580B488P+30"); 17240 assert(ios.width() == 0); 17241 } 17242 } 17243 ios.imbue(lg); 17244 { 17245 ios.width(0); 17246 { 17247 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17248 std::string ex(str, iter.base()); 17249 assert(ex == "+0X1;26580B488P+30"); 17250 assert(ios.width() == 0); 17251 } 17252 ios.width(25); 17253 left(ios); 17254 { 17255 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17256 std::string ex(str, iter.base()); 17257 assert(ex == "+0X1;26580B488P+30*******"); 17258 assert(ios.width() == 0); 17259 } 17260 ios.width(25); 17261 right(ios); 17262 { 17263 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17264 std::string ex(str, iter.base()); 17265 assert(ex == "*******+0X1;26580B488P+30"); 17266 assert(ios.width() == 0); 17267 } 17268 ios.width(25); 17269 internal(ios); 17270 { 17271 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17272 std::string ex(str, iter.base()); 17273 assert(ex == "+*******0X1;26580B488P+30"); 17274 assert(ios.width() == 0); 17275 } 17276 } 17277 } 17278 } 17279 } 17280 } 17281 ios.precision(6); 17282 { 17283 } 17284 ios.precision(16); 17285 { 17286 } 17287 ios.precision(60); 17288 { 17289 nouppercase(ios); 17290 { 17291 noshowpos(ios); 17292 { 17293 noshowpoint(ios); 17294 { 17295 ios.imbue(lc); 17296 { 17297 ios.width(0); 17298 { 17299 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17300 std::string ex(str, iter.base()); 17301 assert(ex == "0x1.26580b488p+30"); 17302 assert(ios.width() == 0); 17303 } 17304 ios.width(25); 17305 left(ios); 17306 { 17307 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17308 std::string ex(str, iter.base()); 17309 assert(ex == "0x1.26580b488p+30********"); 17310 assert(ios.width() == 0); 17311 } 17312 ios.width(25); 17313 right(ios); 17314 { 17315 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17316 std::string ex(str, iter.base()); 17317 assert(ex == "********0x1.26580b488p+30"); 17318 assert(ios.width() == 0); 17319 } 17320 ios.width(25); 17321 internal(ios); 17322 { 17323 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17324 std::string ex(str, iter.base()); 17325 assert(ex == "0x********1.26580b488p+30"); 17326 assert(ios.width() == 0); 17327 } 17328 } 17329 ios.imbue(lg); 17330 { 17331 ios.width(0); 17332 { 17333 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17334 std::string ex(str, iter.base()); 17335 assert(ex == "0x1;26580b488p+30"); 17336 assert(ios.width() == 0); 17337 } 17338 ios.width(25); 17339 left(ios); 17340 { 17341 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17342 std::string ex(str, iter.base()); 17343 assert(ex == "0x1;26580b488p+30********"); 17344 assert(ios.width() == 0); 17345 } 17346 ios.width(25); 17347 right(ios); 17348 { 17349 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17350 std::string ex(str, iter.base()); 17351 assert(ex == "********0x1;26580b488p+30"); 17352 assert(ios.width() == 0); 17353 } 17354 ios.width(25); 17355 internal(ios); 17356 { 17357 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17358 std::string ex(str, iter.base()); 17359 assert(ex == "0x********1;26580b488p+30"); 17360 assert(ios.width() == 0); 17361 } 17362 } 17363 } 17364 showpoint(ios); 17365 { 17366 ios.imbue(lc); 17367 { 17368 ios.width(0); 17369 { 17370 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17371 std::string ex(str, iter.base()); 17372 assert(ex == "0x1.26580b488p+30"); 17373 assert(ios.width() == 0); 17374 } 17375 ios.width(25); 17376 left(ios); 17377 { 17378 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17379 std::string ex(str, iter.base()); 17380 assert(ex == "0x1.26580b488p+30********"); 17381 assert(ios.width() == 0); 17382 } 17383 ios.width(25); 17384 right(ios); 17385 { 17386 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17387 std::string ex(str, iter.base()); 17388 assert(ex == "********0x1.26580b488p+30"); 17389 assert(ios.width() == 0); 17390 } 17391 ios.width(25); 17392 internal(ios); 17393 { 17394 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17395 std::string ex(str, iter.base()); 17396 assert(ex == "0x********1.26580b488p+30"); 17397 assert(ios.width() == 0); 17398 } 17399 } 17400 ios.imbue(lg); 17401 { 17402 ios.width(0); 17403 { 17404 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17405 std::string ex(str, iter.base()); 17406 assert(ex == "0x1;26580b488p+30"); 17407 assert(ios.width() == 0); 17408 } 17409 ios.width(25); 17410 left(ios); 17411 { 17412 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17413 std::string ex(str, iter.base()); 17414 assert(ex == "0x1;26580b488p+30********"); 17415 assert(ios.width() == 0); 17416 } 17417 ios.width(25); 17418 right(ios); 17419 { 17420 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17421 std::string ex(str, iter.base()); 17422 assert(ex == "********0x1;26580b488p+30"); 17423 assert(ios.width() == 0); 17424 } 17425 ios.width(25); 17426 internal(ios); 17427 { 17428 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17429 std::string ex(str, iter.base()); 17430 assert(ex == "0x********1;26580b488p+30"); 17431 assert(ios.width() == 0); 17432 } 17433 } 17434 } 17435 } 17436 showpos(ios); 17437 { 17438 noshowpoint(ios); 17439 { 17440 ios.imbue(lc); 17441 { 17442 ios.width(0); 17443 { 17444 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17445 std::string ex(str, iter.base()); 17446 assert(ex == "+0x1.26580b488p+30"); 17447 assert(ios.width() == 0); 17448 } 17449 ios.width(25); 17450 left(ios); 17451 { 17452 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17453 std::string ex(str, iter.base()); 17454 assert(ex == "+0x1.26580b488p+30*******"); 17455 assert(ios.width() == 0); 17456 } 17457 ios.width(25); 17458 right(ios); 17459 { 17460 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17461 std::string ex(str, iter.base()); 17462 assert(ex == "*******+0x1.26580b488p+30"); 17463 assert(ios.width() == 0); 17464 } 17465 ios.width(25); 17466 internal(ios); 17467 { 17468 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17469 std::string ex(str, iter.base()); 17470 assert(ex == "+*******0x1.26580b488p+30"); 17471 assert(ios.width() == 0); 17472 } 17473 } 17474 ios.imbue(lg); 17475 { 17476 ios.width(0); 17477 { 17478 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17479 std::string ex(str, iter.base()); 17480 assert(ex == "+0x1;26580b488p+30"); 17481 assert(ios.width() == 0); 17482 } 17483 ios.width(25); 17484 left(ios); 17485 { 17486 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17487 std::string ex(str, iter.base()); 17488 assert(ex == "+0x1;26580b488p+30*******"); 17489 assert(ios.width() == 0); 17490 } 17491 ios.width(25); 17492 right(ios); 17493 { 17494 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17495 std::string ex(str, iter.base()); 17496 assert(ex == "*******+0x1;26580b488p+30"); 17497 assert(ios.width() == 0); 17498 } 17499 ios.width(25); 17500 internal(ios); 17501 { 17502 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17503 std::string ex(str, iter.base()); 17504 assert(ex == "+*******0x1;26580b488p+30"); 17505 assert(ios.width() == 0); 17506 } 17507 } 17508 } 17509 showpoint(ios); 17510 { 17511 ios.imbue(lc); 17512 { 17513 ios.width(0); 17514 { 17515 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17516 std::string ex(str, iter.base()); 17517 assert(ex == "+0x1.26580b488p+30"); 17518 assert(ios.width() == 0); 17519 } 17520 ios.width(25); 17521 left(ios); 17522 { 17523 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17524 std::string ex(str, iter.base()); 17525 assert(ex == "+0x1.26580b488p+30*******"); 17526 assert(ios.width() == 0); 17527 } 17528 ios.width(25); 17529 right(ios); 17530 { 17531 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17532 std::string ex(str, iter.base()); 17533 assert(ex == "*******+0x1.26580b488p+30"); 17534 assert(ios.width() == 0); 17535 } 17536 ios.width(25); 17537 internal(ios); 17538 { 17539 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17540 std::string ex(str, iter.base()); 17541 assert(ex == "+*******0x1.26580b488p+30"); 17542 assert(ios.width() == 0); 17543 } 17544 } 17545 ios.imbue(lg); 17546 { 17547 ios.width(0); 17548 { 17549 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17550 std::string ex(str, iter.base()); 17551 assert(ex == "+0x1;26580b488p+30"); 17552 assert(ios.width() == 0); 17553 } 17554 ios.width(25); 17555 left(ios); 17556 { 17557 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17558 std::string ex(str, iter.base()); 17559 assert(ex == "+0x1;26580b488p+30*******"); 17560 assert(ios.width() == 0); 17561 } 17562 ios.width(25); 17563 right(ios); 17564 { 17565 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17566 std::string ex(str, iter.base()); 17567 assert(ex == "*******+0x1;26580b488p+30"); 17568 assert(ios.width() == 0); 17569 } 17570 ios.width(25); 17571 internal(ios); 17572 { 17573 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17574 std::string ex(str, iter.base()); 17575 assert(ex == "+*******0x1;26580b488p+30"); 17576 assert(ios.width() == 0); 17577 } 17578 } 17579 } 17580 } 17581 } 17582 uppercase(ios); 17583 { 17584 noshowpos(ios); 17585 { 17586 noshowpoint(ios); 17587 { 17588 ios.imbue(lc); 17589 { 17590 ios.width(0); 17591 { 17592 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17593 std::string ex(str, iter.base()); 17594 assert(ex == "0X1.26580B488P+30"); 17595 assert(ios.width() == 0); 17596 } 17597 ios.width(25); 17598 left(ios); 17599 { 17600 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17601 std::string ex(str, iter.base()); 17602 assert(ex == "0X1.26580B488P+30********"); 17603 assert(ios.width() == 0); 17604 } 17605 ios.width(25); 17606 right(ios); 17607 { 17608 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17609 std::string ex(str, iter.base()); 17610 assert(ex == "********0X1.26580B488P+30"); 17611 assert(ios.width() == 0); 17612 } 17613 ios.width(25); 17614 internal(ios); 17615 { 17616 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17617 std::string ex(str, iter.base()); 17618 assert(ex == "0X********1.26580B488P+30"); 17619 assert(ios.width() == 0); 17620 } 17621 } 17622 ios.imbue(lg); 17623 { 17624 ios.width(0); 17625 { 17626 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17627 std::string ex(str, iter.base()); 17628 assert(ex == "0X1;26580B488P+30"); 17629 assert(ios.width() == 0); 17630 } 17631 ios.width(25); 17632 left(ios); 17633 { 17634 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17635 std::string ex(str, iter.base()); 17636 assert(ex == "0X1;26580B488P+30********"); 17637 assert(ios.width() == 0); 17638 } 17639 ios.width(25); 17640 right(ios); 17641 { 17642 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17643 std::string ex(str, iter.base()); 17644 assert(ex == "********0X1;26580B488P+30"); 17645 assert(ios.width() == 0); 17646 } 17647 ios.width(25); 17648 internal(ios); 17649 { 17650 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17651 std::string ex(str, iter.base()); 17652 assert(ex == "0X********1;26580B488P+30"); 17653 assert(ios.width() == 0); 17654 } 17655 } 17656 } 17657 showpoint(ios); 17658 { 17659 ios.imbue(lc); 17660 { 17661 ios.width(0); 17662 { 17663 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17664 std::string ex(str, iter.base()); 17665 assert(ex == "0X1.26580B488P+30"); 17666 assert(ios.width() == 0); 17667 } 17668 ios.width(25); 17669 left(ios); 17670 { 17671 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17672 std::string ex(str, iter.base()); 17673 assert(ex == "0X1.26580B488P+30********"); 17674 assert(ios.width() == 0); 17675 } 17676 ios.width(25); 17677 right(ios); 17678 { 17679 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17680 std::string ex(str, iter.base()); 17681 assert(ex == "********0X1.26580B488P+30"); 17682 assert(ios.width() == 0); 17683 } 17684 ios.width(25); 17685 internal(ios); 17686 { 17687 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17688 std::string ex(str, iter.base()); 17689 assert(ex == "0X********1.26580B488P+30"); 17690 assert(ios.width() == 0); 17691 } 17692 } 17693 ios.imbue(lg); 17694 { 17695 ios.width(0); 17696 { 17697 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17698 std::string ex(str, iter.base()); 17699 assert(ex == "0X1;26580B488P+30"); 17700 assert(ios.width() == 0); 17701 } 17702 ios.width(25); 17703 left(ios); 17704 { 17705 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17706 std::string ex(str, iter.base()); 17707 assert(ex == "0X1;26580B488P+30********"); 17708 assert(ios.width() == 0); 17709 } 17710 ios.width(25); 17711 right(ios); 17712 { 17713 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17714 std::string ex(str, iter.base()); 17715 assert(ex == "********0X1;26580B488P+30"); 17716 assert(ios.width() == 0); 17717 } 17718 ios.width(25); 17719 internal(ios); 17720 { 17721 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17722 std::string ex(str, iter.base()); 17723 assert(ex == "0X********1;26580B488P+30"); 17724 assert(ios.width() == 0); 17725 } 17726 } 17727 } 17728 } 17729 showpos(ios); 17730 { 17731 noshowpoint(ios); 17732 { 17733 ios.imbue(lc); 17734 { 17735 ios.width(0); 17736 { 17737 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17738 std::string ex(str, iter.base()); 17739 assert(ex == "+0X1.26580B488P+30"); 17740 assert(ios.width() == 0); 17741 } 17742 ios.width(25); 17743 left(ios); 17744 { 17745 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17746 std::string ex(str, iter.base()); 17747 assert(ex == "+0X1.26580B488P+30*******"); 17748 assert(ios.width() == 0); 17749 } 17750 ios.width(25); 17751 right(ios); 17752 { 17753 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17754 std::string ex(str, iter.base()); 17755 assert(ex == "*******+0X1.26580B488P+30"); 17756 assert(ios.width() == 0); 17757 } 17758 ios.width(25); 17759 internal(ios); 17760 { 17761 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17762 std::string ex(str, iter.base()); 17763 assert(ex == "+*******0X1.26580B488P+30"); 17764 assert(ios.width() == 0); 17765 } 17766 } 17767 ios.imbue(lg); 17768 { 17769 ios.width(0); 17770 { 17771 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17772 std::string ex(str, iter.base()); 17773 assert(ex == "+0X1;26580B488P+30"); 17774 assert(ios.width() == 0); 17775 } 17776 ios.width(25); 17777 left(ios); 17778 { 17779 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17780 std::string ex(str, iter.base()); 17781 assert(ex == "+0X1;26580B488P+30*******"); 17782 assert(ios.width() == 0); 17783 } 17784 ios.width(25); 17785 right(ios); 17786 { 17787 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17788 std::string ex(str, iter.base()); 17789 assert(ex == "*******+0X1;26580B488P+30"); 17790 assert(ios.width() == 0); 17791 } 17792 ios.width(25); 17793 internal(ios); 17794 { 17795 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17796 std::string ex(str, iter.base()); 17797 assert(ex == "+*******0X1;26580B488P+30"); 17798 assert(ios.width() == 0); 17799 } 17800 } 17801 } 17802 showpoint(ios); 17803 { 17804 ios.imbue(lc); 17805 { 17806 ios.width(0); 17807 { 17808 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17809 std::string ex(str, iter.base()); 17810 assert(ex == "+0X1.26580B488P+30"); 17811 assert(ios.width() == 0); 17812 } 17813 ios.width(25); 17814 left(ios); 17815 { 17816 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17817 std::string ex(str, iter.base()); 17818 assert(ex == "+0X1.26580B488P+30*******"); 17819 assert(ios.width() == 0); 17820 } 17821 ios.width(25); 17822 right(ios); 17823 { 17824 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17825 std::string ex(str, iter.base()); 17826 assert(ex == "*******+0X1.26580B488P+30"); 17827 assert(ios.width() == 0); 17828 } 17829 ios.width(25); 17830 internal(ios); 17831 { 17832 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17833 std::string ex(str, iter.base()); 17834 assert(ex == "+*******0X1.26580B488P+30"); 17835 assert(ios.width() == 0); 17836 } 17837 } 17838 ios.imbue(lg); 17839 { 17840 ios.width(0); 17841 { 17842 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17843 std::string ex(str, iter.base()); 17844 assert(ex == "+0X1;26580B488P+30"); 17845 assert(ios.width() == 0); 17846 } 17847 ios.width(25); 17848 left(ios); 17849 { 17850 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17851 std::string ex(str, iter.base()); 17852 assert(ex == "+0X1;26580B488P+30*******"); 17853 assert(ios.width() == 0); 17854 } 17855 ios.width(25); 17856 right(ios); 17857 { 17858 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17859 std::string ex(str, iter.base()); 17860 assert(ex == "*******+0X1;26580B488P+30"); 17861 assert(ios.width() == 0); 17862 } 17863 ios.width(25); 17864 internal(ios); 17865 { 17866 iter = f.put(output_iterator<char*>(str), ios, '*', v); 17867 std::string ex(str, iter.base()); 17868 assert(ex == "+*******0X1;26580B488P+30"); 17869 assert(ios.width() == 0); 17870 } 17871 } 17872 } 17873 } 17874 } 17875 } 17876 } 17877 } 17878 } 17879 17880 int main() 17881 { 17882 test1(); 17883 test2(); 17884 test3(); 17885 test4(); 17886 test5(); 17887 test6(); 17888 test7(); 17889 test8(); 17890 } 17891
