ceph/src/boost/libs/beast/test/beast/core/static_string.cpp

   1 //
   2 // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
   3 //
   4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // Official repository: https://github.com/boostorg/beast
   8 //
   9
  10 // Test that header file is self-contained.
  11 #include <boost/beast/core/static_string.hpp>
  12
  13 #include <boost/beast/_experimental/unit_test/suite.hpp>
  14
  15 namespace boost {
  16 namespace beast {
  17
  18 class static_string_test : public beast::unit_test::suite
  19 {
  20 public:
  21     void
  22     testConstruct()
  23     {
  24         {
  25             static_string<1> s;
  26             BEAST_EXPECT(s.empty());
  27             BEAST_EXPECT(s.size() == 0);
  28             BEAST_EXPECT(s == "");
  29             BEAST_EXPECT(*s.end() == 0);
  30         }
  31         {
  32             static_string<4> s1(3, 'x');
  33             BEAST_EXPECT(! s1.empty());
  34             BEAST_EXPECT(s1.size() == 3);
  35             BEAST_EXPECT(s1 == "xxx");
  36             BEAST_EXPECT(*s1.end() == 0);
  37             try
  38             {
  39                 static_string<2> s2(3, 'x');
  40                 fail("", __FILE__, __LINE__);
  41             }
  42             catch(std::length_error const&)
  43             {
  44                 pass();
  45             }
  46         }
  47         {
  48             static_string<5> s1("12345");
  49             BEAST_EXPECT(*s1.end() == 0);
  50             static_string<3> s2(s1, 2);
  51             BEAST_EXPECT(s2 == "345");
  52             BEAST_EXPECT(*s2.end() == 0);
  53             static_string<0> s3(s1, 5);
  54             BEAST_EXPECT(s3.empty());
  55             BEAST_EXPECT(s3.front() == 0);
  56             BEAST_EXPECT(*s3.end() == 0);
  57         }
  58         {
  59             static_string<5> s1("12345");
  60             static_string<2> s2(s1, 1, 2);
  61             BEAST_EXPECT(s2 == "23");
  62             BEAST_EXPECT(*s2.end() == 0);
  63             static_string<0> s3(s1, 5, 1);
  64             BEAST_EXPECT(s3.empty());
  65             BEAST_EXPECT(s3.front() == 0);
  66             BEAST_EXPECT(*s3.end() == 0);
  67             try
  68             {
  69                 static_string<5> s4(s1, 6);
  70                 fail("", __FILE__, __LINE__);
  71             }
  72             catch(std::out_of_range const&)
  73             {
  74                 pass();
  75             }
  76         }
  77         {
  78             static_string<5> s1("UVXYZ", 3);
  79             BEAST_EXPECT(s1 == "UVX");
  80             BEAST_EXPECT(*s1.end() == 0);
  81             static_string<5> s2("X\0""Y\0""Z", 3);
  82             BEAST_EXPECT(std::memcmp(
  83                 s2.data(), "X\0""Y", 3) == 0);
  84             BEAST_EXPECT(*s2.end() == 0);
  85         }
  86         {
  87             static_string<5> s1("12345");
  88             static_string<3> s2(
  89                 s1.begin() + 1, s1.begin() + 3);
  90             BEAST_EXPECT(s2 == "23");
  91             BEAST_EXPECT(*s2.end() == 0);
  92         }
  93         {
  94             static_string<5> s1("12345");
  95             static_string<5> s2(s1);
  96             BEAST_EXPECT(s2 == "12345");
  97             BEAST_EXPECT(*s2.end() == 0);
  98             static_string<6> s3(s1);
  99             BEAST_EXPECT(s3 == "12345");
 100             BEAST_EXPECT(*s3.end() == 0);
 101             try
 102             {
 103                 static_string<4> s4(s1);
 104                 fail("", __FILE__, __LINE__);
 105             }
 106             catch(std::length_error const&)
 107             {
 108                 pass();
 109             }
 110         }
 111         {
 112             static_string<3> s1({'1', '2', '3'});
 113             BEAST_EXPECT(s1 == "123");
 114             BEAST_EXPECT(*s1.end() == 0);
 115             BEAST_EXPECT(
 116                 static_string<0>({}) == static_string<0>());
 117             try
 118             {
 119                 static_string<2> s2({'1', '2', '3'});
 120                 fail("", __FILE__, __LINE__);
 121             }
 122             catch(std::length_error const&)
 123             {
 124                 pass();
 125             }
 126         }
 127         {
 128             static_string<3> s1(
 129                 string_view("123"));
 130             BEAST_EXPECT(s1 == "123");
 131             BEAST_EXPECT(*s1.end() == 0);
 132             try
 133             {
 134                 static_string<2> s2(
 135                     string_view("123"));
 136                 fail("", __FILE__, __LINE__);
 137             }
 138             catch(std::length_error const&)
 139             {
 140                 pass();
 141             }
 142         }
 143         {
 144             static_string<5> s1(
 145                 std::string("12345"), 2, 2);
 146             BEAST_EXPECT(s1 == "34");
 147             BEAST_EXPECT(*s1.end() == 0);
 148             try
 149             {
 150                 static_string<2> s2(
 151                     std::string("12345"), 1, 3);
 152                 fail("", __FILE__, __LINE__);
 153             }
 154             catch(std::length_error const&)
 155             {
 156                 pass();
 157             }
 158         }
 159     }
 160
 161     void
 162     testAssign()
 163     {
 164         {
 165             static_string<3> s1("123");
 166             static_string<3> s2;
 167             s2 = s1;
 168             BEAST_EXPECT(s2 == "123");
 169             BEAST_EXPECT(*s2.end() == 0);
 170         }
 171         {
 172             static_string<3> s1("123");
 173             static_string<5> s2;
 174             s2 = s1;
 175             BEAST_EXPECT(s2 == "123");
 176             BEAST_EXPECT(*s2.end() == 0);
 177             try
 178             {
 179                 static_string<1> s3;
 180                 s3 = s1;
 181                 fail("", __FILE__, __LINE__);
 182             }
 183             catch(std::length_error const&)
 184             {
 185                 pass();
 186             }
 187         }
 188         {
 189             static_string<3> s1;
 190             s1 = "123";
 191             BEAST_EXPECT(s1 == "123");
 192             BEAST_EXPECT(*s1.end() == 0);
 193             try
 194             {
 195                 static_string<1> s2;
 196                 s2 = "123";
 197                 fail("", __FILE__, __LINE__);
 198             }
 199             catch(std::length_error const&)
 200             {
 201                 pass();
 202             }
 203         }
 204         {
 205             static_string<1> s1;
 206             s1 = 'x';
 207             BEAST_EXPECT(s1 == "x");
 208             BEAST_EXPECT(*s1.end() == 0);
 209             try
 210             {
 211                 static_string<0> s2;
 212                 s2 = 'x';
 213                 fail("", __FILE__, __LINE__);
 214             }
 215             catch(std::length_error const&)
 216             {
 217                 pass();
 218             }
 219         }
 220         {
 221             static_string<3> s1;
 222             s1 = {'1', '2', '3'};
 223             BEAST_EXPECT(s1 == "123");
 224             BEAST_EXPECT(*s1.end() == 0);
 225             try
 226             {
 227                 static_string<1> s2;
 228                 s2 = {'1', '2', '3'};
 229                 fail("", __FILE__, __LINE__);
 230             }
 231             catch(std::length_error const&)
 232             {
 233                 pass();
 234             }
 235         }
 236         {
 237             static_string<3> s1;
 238             s1 = string_view("123");
 239             BEAST_EXPECT(s1 == "123");
 240             BEAST_EXPECT(*s1.end() == 0);
 241             try
 242             {
 243                 static_string<1> s2;
 244                 s2 = string_view("123");
 245                 fail("", __FILE__, __LINE__);
 246             }
 247             catch(std::length_error const&)
 248             {
 249                 pass();
 250             }
 251         }
 252
 253         {
 254             static_string<4> s1;
 255             s1.assign(3, 'x');
 256             BEAST_EXPECT(s1 == "xxx");
 257             BEAST_EXPECT(*s1.end() == 0);
 258             try
 259             {
 260                 static_string<2> s2;
 261                 s2.assign(3, 'x');
 262                 fail("", __FILE__, __LINE__);
 263             }
 264             catch(std::length_error const&)
 265             {
 266                 pass();
 267             }
 268         }
 269         {
 270             static_string<5> s1("12345");
 271             BEAST_EXPECT(*s1.end() == 0);
 272             static_string<5> s2;
 273             s2.assign(s1);
 274             BEAST_EXPECT(s2 == "12345");
 275             BEAST_EXPECT(*s2.end() == 0);
 276         }
 277         {
 278             static_string<5> s1("12345");
 279             BEAST_EXPECT(*s1.end() == 0);
 280             static_string<7> s2;
 281             s2.assign(s1);
 282             BEAST_EXPECT(s2 == "12345");
 283             BEAST_EXPECT(*s2.end() == 0);
 284             try
 285             {
 286                 static_string<3> s3;
 287                 s3.assign(s1);
 288                 fail("", __FILE__, __LINE__);
 289             }
 290             catch(std::length_error const&)
 291             {
 292                 pass();
 293             }
 294         }
 295         {
 296             static_string<5> s1("12345");
 297             static_string<5> s2;
 298             s2.assign(s1, 1);
 299             BEAST_EXPECT(s2 == "2345");
 300             BEAST_EXPECT(*s2.end() == 0);
 301             s2.assign(s1, 1, 2);
 302             BEAST_EXPECT(s2 == "23");
 303             BEAST_EXPECT(*s2.end() == 0);
 304             s2.assign(s1, 1, 100);
 305             BEAST_EXPECT(s2 == "2345");
 306             BEAST_EXPECT(*s2.end() == 0);
 307             try
 308             {
 309                 s2.assign(s1, 6);
 310                 fail("", __FILE__, __LINE__);
 311             }
 312             catch(std::out_of_range const&)
 313             {
 314                 pass();
 315             }
 316             try
 317             {
 318                 static_string<3> s3;
 319                 s3.assign(s1, 1);
 320                 fail("", __FILE__, __LINE__);
 321             }
 322             catch(std::length_error const&)
 323             {
 324                 pass();
 325             }
 326         }
 327         {
 328             static_string<5> s1;
 329             s1.assign("12");
 330             BEAST_EXPECT(s1 == "12");
 331             BEAST_EXPECT(*s1.end() == 0);
 332             s1.assign("12345");
 333             BEAST_EXPECT(s1 == "12345");
 334             BEAST_EXPECT(*s1.end() == 0);
 335         }
 336         {
 337             static_string<5> s1;
 338             s1.assign("12345", 3);
 339             BEAST_EXPECT(s1 == "123");
 340             BEAST_EXPECT(*s1.end() == 0);
 341         }
 342         {
 343             static_string<5> s1("12345");
 344             static_string<3> s2;
 345             s2.assign(s1.begin(), s1.begin() + 2);
 346             BEAST_EXPECT(s2 == "12");
 347             BEAST_EXPECT(*s2.end() == 0);
 348             try
 349             {
 350                 s2.assign(s1.begin(), s1.end());
 351                 fail("", __FILE__, __LINE__);
 352             }
 353             catch(std::length_error const&)
 354             {
 355                 pass();
 356             }
 357         }
 358         {
 359             static_string<5> s1;
 360             s1.assign({'1', '2', '3'});
 361             BEAST_EXPECT(s1 == "123");
 362             BEAST_EXPECT(*s1.end() == 0);
 363             try
 364             {
 365                 static_string<1> s2;
 366                 s2.assign({'1', '2', '3'});
 367                 fail("", __FILE__, __LINE__);
 368             }
 369             catch(std::length_error const&)
 370             {
 371                 pass();
 372             }
 373         }
 374         {
 375             static_string<5> s1;
 376             s1.assign(string_view("123"));
 377             BEAST_EXPECT(s1 == "123");
 378             BEAST_EXPECT(*s1.end() == 0);
 379             s1.assign(string_view("12345"));
 380             BEAST_EXPECT(s1 == "12345");
 381             BEAST_EXPECT(*s1.end() == 0);
 382             try
 383             {
 384                 s1.assign(string_view("1234567"));
 385                 fail("", __FILE__, __LINE__);
 386             }
 387             catch(std::length_error const&)
 388             {
 389                 pass();
 390             }
 391         }
 392         {
 393             static_string<5> s1;
 394             s1.assign(std::string("12345"), 2, 2);
 395             BEAST_EXPECT(s1 == "34");
 396             BEAST_EXPECT(*s1.end() == 0);
 397             s1.assign(std::string("12345"), 3);
 398             BEAST_EXPECT(s1 == "45");
 399             BEAST_EXPECT(*s1.end() == 0);
 400             try
 401             {
 402                 static_string<2> s2;
 403                 s2.assign(
 404                     std::string("12345"), 1, 3);
 405                 fail("", __FILE__, __LINE__);
 406             }
 407             catch(std::length_error const&)
 408             {
 409                 pass();
 410             }
 411         }
 412     }
 413
 414     void
 415     testAccess()
 416     {
 417         {
 418             static_string<5> s("12345");
 419             BEAST_EXPECT(s.at(1) == '2');
 420             BEAST_EXPECT(s.at(4) == '5');
 421             try
 422             {
 423                 BEAST_EXPECT(s.at(5) == 0);
 424                 fail("", __FILE__, __LINE__);
 425             }
 426             catch(std::out_of_range const&)
 427             {
 428                 pass();
 429             }
 430         }
 431         {
 432             static_string<5> const s("12345");
 433             BEAST_EXPECT(s.at(1) == '2');
 434             BEAST_EXPECT(s.at(4) == '5');
 435             try
 436             {
 437                 BEAST_EXPECT(s.at(5) == 0);
 438                 fail("", __FILE__, __LINE__);
 439             }
 440             catch(std::out_of_range const&)
 441             {
 442                 pass();
 443             }
 444         }
 445         {
 446             static_string<5> s("12345");
 447             BEAST_EXPECT(s[1] == '2');
 448             BEAST_EXPECT(s[4] == '5');
 449             s[1] = '_';
 450             BEAST_EXPECT(s == "1_345");
 451         }
 452         {
 453             static_string<5> const s("12345");
 454             BEAST_EXPECT(s[1] == '2');
 455             BEAST_EXPECT(s[4] == '5');
 456             BEAST_EXPECT(s[5] == 0);
 457         }
 458         {
 459             static_string<3> s("123");
 460             BEAST_EXPECT(s.front() == '1');
 461             BEAST_EXPECT(s.back() == '3');
 462             s.front() = '_';
 463             BEAST_EXPECT(s == "_23");
 464             s.back() = '_';
 465             BEAST_EXPECT(s == "_2_");
 466         }
 467         {
 468             static_string<3> const s("123");
 469             BEAST_EXPECT(s.front() == '1');
 470             BEAST_EXPECT(s.back() == '3');
 471         }
 472         {
 473             static_string<3> s("123");
 474             BEAST_EXPECT(std::memcmp(
 475                 s.data(), "123", 3) == 0);
 476         }
 477         {
 478             static_string<3> const s("123");
 479             BEAST_EXPECT(std::memcmp(
 480                 s.data(), "123", 3) == 0);
 481         }
 482         {
 483             static_string<3> s("123");
 484             BEAST_EXPECT(std::memcmp(
 485                 s.c_str(), "123\0", 4) == 0);
 486         }
 487         {
 488             static_string<3> s("123");
 489             string_view sv = s;
 490             BEAST_EXPECT(static_string<5>(sv) == "123");
 491         }
 492     }
 493
 494     void
 495     testIterators()
 496     {
 497         {
 498             static_string<3> s;
 499             BEAST_EXPECT(std::distance(
 500                 s.begin(), s.end()) == 0);
 501             BEAST_EXPECT(std::distance(
 502                 s.rbegin(), s.rend()) == 0);
 503             s = "123";
 504             BEAST_EXPECT(std::distance(
 505                 s.begin(), s.end()) == 3);
 506             BEAST_EXPECT(std::distance(
 507                 s.rbegin(), s.rend()) == 3);
 508         }
 509         {
 510             static_string<3> const s("123");
 511             BEAST_EXPECT(std::distance(
 512                 s.begin(), s.end()) == 3);
 513             BEAST_EXPECT(std::distance(
 514                 s.cbegin(), s.cend()) == 3);
 515             BEAST_EXPECT(std::distance(
 516                 s.rbegin(), s.rend()) == 3);
 517             BEAST_EXPECT(std::distance(
 518                 s.crbegin(), s.crend()) == 3);
 519         }
 520     }
 521
 522     void
 523     testCapacity()
 524     {
 525         static_string<3> s;
 526         BEAST_EXPECT(s.empty());
 527         BEAST_EXPECT(s.size() == 0);
 528         BEAST_EXPECT(s.length() == 0);
 529         BEAST_EXPECT(s.max_size() == 3);
 530         BEAST_EXPECT(s.capacity() == 3);
 531         s = "123";
 532         BEAST_EXPECT(! s.empty());
 533         BEAST_EXPECT(s.size() == 3);
 534         BEAST_EXPECT(s.length() == 3);
 535         s.reserve(0);
 536         s.reserve(3);
 537         try
 538         {
 539             s.reserve(4);
 540             fail("", __FILE__, __LINE__);
 541         }
 542         catch(std::length_error const&)
 543         {
 544             pass();
 545         }
 546         s.shrink_to_fit();
 547         BEAST_EXPECT(! s.empty());
 548         BEAST_EXPECT(s.size() == 3);
 549         BEAST_EXPECT(s.length() == 3);
 550         BEAST_EXPECT(*s.end() == 0);
 551     }
 552
 553     void
 554     testOperations()
 555     {
 556         //
 557         // clear
 558         //
 559
 560         {
 561             static_string<3> s("123");
 562             s.clear();
 563             BEAST_EXPECT(s.empty());
 564             BEAST_EXPECT(*s.end() == 0);
 565         }
 566
 567         //
 568         // insert
 569         //
 570
 571         {
 572             // Using 7 as the size causes a miscompile in MSVC14.2 x64 Release
 573             static_string<8> s1("12345");
 574             s1.insert(2, 2, '_');
 575             BEAST_EXPECT(s1 == "12__345");
 576             BEAST_EXPECT(*s1.end() == 0);
 577             try
 578             {
 579                 static_string<6> s2("12345");
 580                 s2.insert(2, 2, '_');
 581                 fail("", __FILE__, __LINE__);
 582             }
 583             catch(std::length_error const&)
 584             {
 585                 pass();
 586             }
 587             try
 588             {
 589                 static_string<6> s2("12345");
 590                 s2.insert(6, 2, '_');
 591                 fail("", __FILE__, __LINE__);
 592             }
 593             catch(std::out_of_range const&)
 594             {
 595                 pass();
 596             }
 597         }
 598         {
 599             static_string<7> s1("12345");
 600             s1.insert(2, "__");
 601             BEAST_EXPECT(s1 == "12__345");
 602             BEAST_EXPECT(*s1.end() == 0);
 603             try
 604             {
 605                 static_string<6> s2("12345");
 606                 s2.insert(2, "__");
 607                 fail("", __FILE__, __LINE__);
 608             }
 609             catch(std::length_error const&)
 610             {
 611                 pass();
 612             }
 613             try
 614             {
 615                 static_string<6> s2("12345");
 616                 s2.insert(6, "__");
 617                 fail("", __FILE__, __LINE__);
 618             }
 619             catch(std::out_of_range const&)
 620             {
 621                 pass();
 622             }
 623         }
 624         {
 625             static_string<7> s1("12345");
 626             s1.insert(2, "TUV", 2);
 627             BEAST_EXPECT(s1 == "12TU345");
 628             BEAST_EXPECT(*s1.end() == 0);
 629             try
 630             {
 631                 static_string<6> s2("12345");
 632                 s2.insert(2, "TUV", 2);
 633                 fail("", __FILE__, __LINE__);
 634             }
 635             catch(std::length_error const&)
 636             {
 637                 pass();
 638             }
 639             try
 640             {
 641                 static_string<6> s2("12345");
 642                 s2.insert(6, "TUV", 2);
 643                 fail("", __FILE__, __LINE__);
 644             }
 645             catch(std::out_of_range const&)
 646             {
 647                 pass();
 648             }
 649         }
 650         {
 651             static_string<7> s1("12345");
 652             s1.insert(2, static_string<3>("TU"));
 653             BEAST_EXPECT(s1 == "12TU345");
 654             BEAST_EXPECT(*s1.end() == 0);
 655             try
 656             {
 657                 static_string<6> s2("12345");
 658                 s2.insert(2, static_string<3>("TUV"));
 659                 fail("", __FILE__, __LINE__);
 660             }
 661             catch(std::length_error const&)
 662             {
 663                 pass();
 664             }
 665             try
 666             {
 667                 static_string<6> s2("12345");
 668                 s2.insert(6, static_string<3>("TUV"));
 669                 fail("", __FILE__, __LINE__);
 670             }
 671             catch(std::out_of_range const&)
 672             {
 673                 pass();
 674             }
 675         }
 676         {
 677             static_string<7> s1("12345");
 678             s1.insert(2, static_string<3>("TUV"), 1);
 679             BEAST_EXPECT(s1 == "12UV345");
 680             BEAST_EXPECT(*s1.end() == 0);
 681             s1 = "12345";
 682             s1.insert(2, static_string<3>("TUV"), 1, 1);
 683             BEAST_EXPECT(s1 == "12U345");
 684             BEAST_EXPECT(*s1.end() == 0);
 685             try
 686             {
 687                 static_string<6> s2("12345");
 688                 s2.insert(2, static_string<3>("TUV"), 1, 2);
 689                 fail("", __FILE__, __LINE__);
 690             }
 691             catch(std::length_error const&)
 692             {
 693                 pass();
 694             }
 695             try
 696             {
 697                 static_string<6> s2("12345");
 698                 s2.insert(6, static_string<3>("TUV"), 1, 2);
 699                 fail("", __FILE__, __LINE__);
 700             }
 701             catch(std::out_of_range const&)
 702             {
 703                 pass();
 704             }
 705         }
 706         {
 707             static_string<4> s1("123");
 708             s1.insert(s1.begin() + 1, '_');
 709             BEAST_EXPECT(s1 == "1_23");
 710             BEAST_EXPECT(*s1.end() == 0);
 711             try
 712             {
 713                 static_string<3> s2("123");
 714                 s2.insert(s2.begin() + 1, '_');
 715                 fail("", __FILE__, __LINE__);
 716             }
 717             catch(std::length_error const&)
 718             {
 719                 pass();
 720             }
 721         }
 722         {
 723             static_string<4> s1("12");
 724             s1.insert(s1.begin() + 1, 2, '_');
 725             BEAST_EXPECT(s1 == "1__2");
 726             BEAST_EXPECT(*s1.end() == 0);
 727             try
 728             {
 729                 static_string<4> s2("123");
 730                 s2.insert(s2.begin() + 1, 2, ' ');
 731                 fail("", __FILE__, __LINE__);
 732             }
 733             catch(std::length_error const&)
 734             {
 735                 pass();
 736             }
 737         }
 738         {
 739             static_string<3> s1("123");
 740             static_string<5> s2("UV");
 741             s2.insert(s2.begin() + 1, s1.begin(), s1.end());
 742             BEAST_EXPECT(s2 == "U123V");
 743             BEAST_EXPECT(*s2.end() == 0);
 744             try
 745             {
 746                 static_string<4> s3("UV");
 747                 s3.insert(s3.begin() + 1, s1.begin(), s1.end());
 748                 fail("", __FILE__, __LINE__);
 749             }
 750             catch(std::length_error const&)
 751             {
 752                 pass();
 753             }
 754         }
 755         {
 756             static_string<5> s1("123");
 757             s1.insert(1, string_view("UV"));
 758             BEAST_EXPECT(s1 == "1UV23");
 759             BEAST_EXPECT(*s1.end() == 0);
 760             try
 761             {
 762                 static_string<4> s2("123");
 763                 s2.insert(1, string_view("UV"));
 764                 fail("", __FILE__, __LINE__);
 765             }
 766             catch(std::length_error const&)
 767             {
 768                 pass();
 769             }
 770             try
 771             {
 772                 static_string<5> s2("123");
 773                 s2.insert(5, string_view("UV"));
 774                 fail("", __FILE__, __LINE__);
 775             }
 776             catch(std::out_of_range const&)
 777             {
 778                 pass();
 779             }
 780         }
 781         {
 782             static_string<5> s1("123");
 783             s1.insert(1, std::string("UV"));
 784             BEAST_EXPECT(s1 == "1UV23");
 785             BEAST_EXPECT(*s1.end() == 0);
 786             try
 787             {
 788                 s1.insert(1, std::string("UV"));
 789                 fail("", __FILE__, __LINE__);
 790             }
 791             catch(std::length_error const&)
 792             {
 793                 pass();
 794             }
 795         }
 796         {
 797             static_string<6> s1("123");
 798             s1.insert(1, std::string("UVX"), 1);
 799             BEAST_EXPECT(s1 == "1VX23");
 800             BEAST_EXPECT(*s1.end() == 0);
 801             s1.insert(4, std::string("PQR"), 1, 1);
 802             BEAST_EXPECT(s1 == "1VX2Q3");
 803             BEAST_EXPECT(*s1.end() == 0);
 804             try
 805             {
 806                 s1.insert(4, std::string("PQR"), 1, 1);
 807                 fail("", __FILE__, __LINE__);
 808             }
 809             catch(std::length_error const&)
 810             {
 811                 pass();
 812             }
 813         }
 814
 815         //
 816         // erase
 817         //
 818
 819         {
 820             static_string<9> s1("123456789");
 821             BEAST_EXPECT(s1.erase(1, 1) == "13456789");
 822             BEAST_EXPECT(s1 == "13456789");
 823             BEAST_EXPECT(*s1.end() == 0);
 824             BEAST_EXPECT(s1.erase(5) == "13456");
 825             BEAST_EXPECT(s1 == "13456");
 826             BEAST_EXPECT(*s1.end() == 0);
 827             try
 828             {
 829                 s1.erase(7);
 830                 fail("", __FILE__, __LINE__);
 831             }
 832             catch(std::out_of_range const&)
 833             {
 834                 pass();
 835             }
 836         }
 837         {
 838             static_string<9> s1("123456789");
 839             BEAST_EXPECT(*s1.erase(s1.begin() + 5) == '7');
 840             BEAST_EXPECT(s1 == "12345789");
 841             BEAST_EXPECT(*s1.end() == 0);
 842         }
 843         {
 844             static_string<9> s1("123456789");
 845             BEAST_EXPECT(*s1.erase(
 846                 s1.begin() + 5, s1.begin() + 7) == '8');
 847             BEAST_EXPECT(s1 == "1234589");
 848             BEAST_EXPECT(*s1.end() == 0);
 849         }
 850
 851         //
 852         // push_back
 853         //
 854
 855         {
 856             static_string<3> s1("12");
 857             s1.push_back('3');
 858             BEAST_EXPECT(s1 == "123");
 859             try
 860             {
 861                 s1.push_back('4');
 862                 fail("", __FILE__, __LINE__);
 863             }
 864             catch(std::length_error const&)
 865             {
 866                 pass();
 867             }
 868             static_string<0> s2;
 869             try
 870             {
 871                 s2.push_back('_');
 872                 fail("", __FILE__, __LINE__);
 873             }
 874             catch(std::length_error const&)
 875             {
 876                 pass();
 877             }
 878         }
 879
 880         //
 881         // pop_back
 882         //
 883
 884         {
 885             static_string<3> s1("123");
 886             s1.pop_back();
 887             BEAST_EXPECT(s1 == "12");
 888             BEAST_EXPECT(*s1.end() == 0);
 889             s1.pop_back();
 890             BEAST_EXPECT(s1 == "1");
 891             BEAST_EXPECT(*s1.end() == 0);
 892             s1.pop_back();
 893             BEAST_EXPECT(s1.empty());
 894             BEAST_EXPECT(*s1.end() == 0);
 895         }
 896
 897         //
 898         // append
 899         //
 900
 901         {
 902             static_string<3> s1("1");
 903             s1.append(2, '_');
 904             BEAST_EXPECT(s1 == "1__");
 905             BEAST_EXPECT(*s1.end() == 0);
 906             try
 907             {
 908                 static_string<2> s2("1");
 909                 s2.append(2, '_');
 910                 fail("", __FILE__, __LINE__);
 911             }
 912             catch(std::length_error const&)
 913             {
 914                 pass();
 915             }
 916         }
 917         {
 918             static_string<2> s1("__");
 919             static_string<3> s2("1");
 920             s2.append(s1);
 921             BEAST_EXPECT(s2 == "1__");
 922             BEAST_EXPECT(*s2.end() == 0);
 923             try
 924             {
 925                 static_string<2> s3("1");
 926                 s3.append(s1);
 927                 fail("", __FILE__, __LINE__);
 928             }
 929             catch(std::length_error const&)
 930             {
 931                 pass();
 932             }
 933         }
 934         {
 935             static_string<3> s1("XYZ");
 936             static_string<4> s2("12");
 937             s2.append(s1, 1);
 938             BEAST_EXPECT(s2 == "12YZ");
 939             BEAST_EXPECT(*s2.end() == 0);
 940             static_string<3> s3("12");
 941             s3.append(s1, 1, 1);
 942             BEAST_EXPECT(s3 == "12Y");
 943             BEAST_EXPECT(*s3.end() == 0);
 944             try
 945             {
 946                 static_string<3> s4("12");
 947                 s4.append(s1, 3);
 948                 fail("", __FILE__, __LINE__);
 949             }
 950             catch(std::out_of_range const&)
 951             {
 952                 pass();
 953             }
 954             try
 955             {
 956                 static_string<3> s4("12");
 957                 s4.append(s1, 1);
 958                 fail("", __FILE__, __LINE__);
 959             }
 960             catch(std::length_error const&)
 961             {
 962                 pass();
 963             }
 964         }
 965         {
 966             static_string<4> s1("12");
 967             s1.append("XYZ", 2);
 968             BEAST_EXPECT(s1 == "12XY");
 969             BEAST_EXPECT(*s1.end() == 0);
 970             try
 971             {
 972                 static_string<3> s3("12");
 973                 s3.append("XYZ", 2);
 974                 fail("", __FILE__, __LINE__);
 975             }
 976             catch(std::length_error const&)
 977             {
 978                 pass();
 979             }
 980         }
 981         {
 982             static_string<5> s1("12");
 983             s1.append("XYZ");
 984             BEAST_EXPECT(s1 == "12XYZ");
 985             BEAST_EXPECT(*s1.end() == 0);
 986             try
 987             {
 988                 static_string<4> s2("12");
 989                 s2.append("XYZ");
 990                 fail("", __FILE__, __LINE__);
 991             }
 992             catch(std::length_error const&)
 993             {
 994                 pass();
 995             }
 996         }
 997         {
 998             static_string<3> s1("XYZ");
 999             static_string<5> s2("12");
1000             s2.append(s1.begin(), s1.end());
1001             BEAST_EXPECT(s2 == "12XYZ");
1002             BEAST_EXPECT(*s2.end() == 0);
1003             try
1004             {
1005                 static_string<4> s3("12");
1006                 s3.append(s1.begin(), s1.end());
1007                 fail("", __FILE__, __LINE__);
1008             }
1009             catch(std::length_error const&)
1010             {
1011                 pass();
1012             }
1013         }
1014         {
1015             static_string<5> s1("123");
1016             s1.append({'X', 'Y'});
1017             BEAST_EXPECT(s1 == "123XY");
1018             BEAST_EXPECT(*s1.end() == 0);
1019             try
1020             {
1021                 static_string<4> s2("123");
1022                 s2.append({'X', 'Y'});
1023                 fail("", __FILE__, __LINE__);
1024             }
1025             catch(std::length_error const&)
1026             {
1027                 pass();
1028             }
1029         }
1030         {
1031             string_view s1("XYZ");
1032             static_string<5> s2("12");
1033             s2.append(s1);
1034             BEAST_EXPECT(s2 == "12XYZ");
1035             BEAST_EXPECT(*s2.end() == 0);
1036             try
1037             {
1038                 static_string<4> s3("12");
1039                 s3.append(s1);
1040                 fail("", __FILE__, __LINE__);
1041             }
1042             catch(std::length_error const&)
1043             {
1044                 pass();
1045             }
1046         }
1047         {
1048             static_string<6> s1("123");
1049             s1.append(std::string("UVX"), 1);
1050             BEAST_EXPECT(s1 == "123VX");
1051             BEAST_EXPECT(*s1.end() == 0);
1052             s1.append(std::string("PQR"), 1, 1);
1053             BEAST_EXPECT(s1 == "123VXQ");
1054             BEAST_EXPECT(*s1.end() == 0);
1055             try
1056             {
1057                 static_string<3> s2("123");
1058                 s2.append(std::string("PQR"), 1, 1);
1059                 fail("", __FILE__, __LINE__);
1060             }
1061             catch(std::length_error const&)
1062             {
1063                 pass();
1064             }
1065         }
1066
1067         //
1068         // operator+=
1069         //
1070
1071         {
1072             static_string<2> s1("__");
1073             static_string<3> s2("1");
1074             s2 += s1;
1075             BEAST_EXPECT(s2 == "1__");
1076             BEAST_EXPECT(*s2.end() == 0);
1077             try
1078             {
1079                 static_string<2> s3("1");
1080                 s3 += s1;
1081                 fail("", __FILE__, __LINE__);
1082             }
1083             catch(std::length_error const&)
1084             {
1085                 pass();
1086             }
1087         }
1088         {
1089             static_string<3> s1("12");
1090             s1 += '3';
1091             BEAST_EXPECT(s1 == "123");
1092             try
1093             {
1094                 s1 += '4';
1095                 fail("", __FILE__, __LINE__);
1096             }
1097             catch(std::length_error const&)
1098             {
1099                 pass();
1100             }
1101         }
1102         {
1103             static_string<4> s1("12");
1104             s1 += "34";
1105             BEAST_EXPECT(s1 == "1234");
1106             try
1107             {
1108                 s1 += "5";
1109                 fail("", __FILE__, __LINE__);
1110             }
1111             catch(std::length_error const&)
1112             {
1113                 pass();
1114             }
1115         }
1116         {
1117             static_string<4> s1("12");
1118             s1 += {'3', '4'};
1119             BEAST_EXPECT(s1 == "1234");
1120             try
1121             {
1122                 s1 += {'5'};
1123                 fail("", __FILE__, __LINE__);
1124             }
1125             catch(std::length_error const&)
1126             {
1127                 pass();
1128             }
1129         }
1130         {
1131             string_view s1("34");
1132             static_string<4> s2("12");
1133             s2 += s1;
1134             BEAST_EXPECT(s2 == "1234");
1135             try
1136             {
1137                 s2 += s1;
1138                 fail("", __FILE__, __LINE__);
1139             }
1140             catch(std::length_error const&)
1141             {
1142                 pass();
1143             }
1144         }
1145     }
1146
1147     void
1148     testCompare()
1149     {
1150         using str1 = static_string<1>;
1151         using str2 = static_string<2>;
1152         {
1153             str1 s1;
1154             str2 s2;
1155             s1 = "1";
1156             s2 = "22";
1157             BEAST_EXPECT(s1.compare(s2) < 0);
1158             BEAST_EXPECT(s2.compare(s1) > 0);
1159             BEAST_EXPECT(s1 < "10");
1160             BEAST_EXPECT(s2 > "1");
1161             BEAST_EXPECT("10" > s1);
1162             BEAST_EXPECT("1" < s2);
1163             BEAST_EXPECT(s1 < "20");
1164             BEAST_EXPECT(s2 > "1");
1165             BEAST_EXPECT(s2 > "2");
1166         }
1167         {
1168             str2 s1("x");
1169             str2 s2("x");
1170             BEAST_EXPECT(s1 == s2);
1171             BEAST_EXPECT(s1 <= s2);
1172             BEAST_EXPECT(s1 >= s2);
1173             BEAST_EXPECT(! (s1 < s2));
1174             BEAST_EXPECT(! (s1 > s2));
1175             BEAST_EXPECT(! (s1 != s2));
1176         }
1177         {
1178             str1 s1("x");
1179             str2 s2("x");
1180             BEAST_EXPECT(s1 == s2);
1181             BEAST_EXPECT(s1 <= s2);
1182             BEAST_EXPECT(s1 >= s2);
1183             BEAST_EXPECT(! (s1 < s2));
1184             BEAST_EXPECT(! (s1 > s2));
1185             BEAST_EXPECT(! (s1 != s2));
1186         }
1187         {
1188             str2 s("x");
1189             BEAST_EXPECT(s == "x");
1190             BEAST_EXPECT(s <= "x");
1191             BEAST_EXPECT(s >= "x");
1192             BEAST_EXPECT(! (s < "x"));
1193             BEAST_EXPECT(! (s > "x"));
1194             BEAST_EXPECT(! (s != "x"));
1195             BEAST_EXPECT("x" == s);
1196             BEAST_EXPECT("x" <= s);
1197             BEAST_EXPECT("x" >= s);
1198             BEAST_EXPECT(! ("x" < s));
1199             BEAST_EXPECT(! ("x" > s));
1200             BEAST_EXPECT(! ("x" != s));
1201         }
1202         {
1203             str2 s("x");
1204             BEAST_EXPECT(s <= "y");
1205             BEAST_EXPECT(s < "y");
1206             BEAST_EXPECT(s != "y");
1207             BEAST_EXPECT(! (s == "y"));
1208             BEAST_EXPECT(! (s >= "y"));
1209             BEAST_EXPECT(! (s > "x"));
1210             BEAST_EXPECT("y" >= s);
1211             BEAST_EXPECT("y" > s);
1212             BEAST_EXPECT("y" != s);
1213             BEAST_EXPECT(! ("y" == s));
1214             BEAST_EXPECT(! ("y" <= s));
1215             BEAST_EXPECT(! ("y" < s));
1216         }
1217         {
1218             str1 s1("x");
1219             str2 s2("y");
1220             BEAST_EXPECT(s1 <= s2);
1221             BEAST_EXPECT(s1 < s2);
1222             BEAST_EXPECT(s1 != s2);
1223             BEAST_EXPECT(! (s1 == s2));
1224             BEAST_EXPECT(! (s1 >= s2));
1225             BEAST_EXPECT(! (s1 > s2));
1226         }
1227         {
1228             str1 s1("x");
1229             str2 s2("xx");
1230             BEAST_EXPECT(s1 < s2);
1231             BEAST_EXPECT(s2 > s1);
1232         }
1233         {
1234             str1 s1("x");
1235             str2 s2("yy");
1236             BEAST_EXPECT(s1 < s2);
1237             BEAST_EXPECT(s2 > s1);
1238         }
1239     }
1240
1241     void
1242     testSwap()
1243     {
1244         {
1245             static_string<3> s1("123");
1246             static_string<3> s2("XYZ");
1247             swap(s1, s2);
1248             BEAST_EXPECT(s1 == "XYZ");
1249             BEAST_EXPECT(*s1.end() == 0);
1250             BEAST_EXPECT(s2 == "123");
1251             BEAST_EXPECT(*s2.end() == 0);
1252             static_string<3> s3("UV");
1253             swap(s2, s3);
1254             BEAST_EXPECT(s2 == "UV");
1255             BEAST_EXPECT(*s2.end() == 0);
1256             BEAST_EXPECT(s3 == "123");
1257             BEAST_EXPECT(*s3.end() == 0);
1258         }
1259         {
1260             static_string<5> s1("123");
1261             static_string<7> s2("XYZ");
1262             swap(s1, s2);
1263             BEAST_EXPECT(s1 == "XYZ");
1264             BEAST_EXPECT(*s1.end() == 0);
1265             BEAST_EXPECT(s2 == "123");
1266             BEAST_EXPECT(*s2.end() == 0);
1267             static_string<3> s3("UV");
1268             swap(s2, s3);
1269             BEAST_EXPECT(s2 == "UV");
1270             BEAST_EXPECT(*s2.end() == 0);
1271             BEAST_EXPECT(s3 == "123");
1272             BEAST_EXPECT(*s3.end() == 0);
1273             try
1274             {
1275                 static_string<5> s4("12345");
1276                 static_string<3> s5("XYZ");
1277                 swap(s4, s5);
1278                 fail("", __FILE__, __LINE__);
1279             }
1280             catch(std::length_error const&)
1281             {
1282                 pass();
1283             }
1284             try
1285             {
1286                 static_string<3> s4("XYZ");
1287                 static_string<5> s5("12345");
1288                 swap(s4, s5);
1289                 fail("", __FILE__, __LINE__);
1290             }
1291             catch(std::length_error const&)
1292             {
1293                 pass();
1294             }
1295         }
1296     }
1297
1298     void
1299     testGeneral()
1300     {
1301         using str1 = static_string<1>;
1302         using str2 = static_string<2>;
1303         {
1304             str1 s1;
1305             BEAST_EXPECT(s1 == "");
1306             BEAST_EXPECT(s1.empty());
1307             BEAST_EXPECT(s1.size() == 0);
1308             BEAST_EXPECT(s1.max_size() == 1);
1309             BEAST_EXPECT(s1.capacity() == 1);
1310             BEAST_EXPECT(s1.begin() == s1.end());
1311             BEAST_EXPECT(s1.cbegin() == s1.cend());
1312             BEAST_EXPECT(s1.rbegin() == s1.rend());
1313             BEAST_EXPECT(s1.crbegin() == s1.crend());
1314             try
1315             {
1316                 BEAST_EXPECT(s1.at(0) == 0);
1317                 fail();
1318             }
1319             catch(std::exception const&)
1320             {
1321                 pass();
1322             }
1323             BEAST_EXPECT(s1.data()[0] == 0);
1324             BEAST_EXPECT(*s1.c_str() == 0);
1325             BEAST_EXPECT(std::distance(s1.begin(), s1.end()) == 0);
1326             BEAST_EXPECT(std::distance(s1.cbegin(), s1.cend()) == 0);
1327             BEAST_EXPECT(std::distance(s1.rbegin(), s1.rend()) == 0);
1328             BEAST_EXPECT(std::distance(s1.crbegin(), s1.crend()) == 0);
1329             BEAST_EXPECT(s1.compare(s1) == 0);
1330         }
1331         {
1332             str1 const s1;
1333             BEAST_EXPECT(s1 == "");
1334             BEAST_EXPECT(s1.empty());
1335             BEAST_EXPECT(s1.size() == 0);
1336             BEAST_EXPECT(s1.max_size() == 1);
1337             BEAST_EXPECT(s1.capacity() == 1);
1338             BEAST_EXPECT(s1.begin() == s1.end());
1339             BEAST_EXPECT(s1.cbegin() == s1.cend());
1340             BEAST_EXPECT(s1.rbegin() == s1.rend());
1341             BEAST_EXPECT(s1.crbegin() == s1.crend());
1342             try
1343             {
1344                 BEAST_EXPECT(s1.at(0) == 0);
1345                 fail();
1346             }
1347             catch(std::exception const&)
1348             {
1349                 pass();
1350             }
1351             BEAST_EXPECT(s1.data()[0] == 0);
1352             BEAST_EXPECT(*s1.c_str() == 0);
1353             BEAST_EXPECT(std::distance(s1.begin(), s1.end()) == 0);
1354             BEAST_EXPECT(std::distance(s1.cbegin(), s1.cend()) == 0);
1355             BEAST_EXPECT(std::distance(s1.rbegin(), s1.rend()) == 0);
1356             BEAST_EXPECT(std::distance(s1.crbegin(), s1.crend()) == 0);
1357             BEAST_EXPECT(s1.compare(s1) == 0);
1358         }
1359         {
1360             str1 s1;
1361             str1 s2("x");
1362             BEAST_EXPECT(s2 == "x");
1363             BEAST_EXPECT(s2[0] == 'x');
1364             BEAST_EXPECT(s2.at(0) == 'x');
1365             BEAST_EXPECT(s2.front() == 'x');
1366             BEAST_EXPECT(s2.back() == 'x');
1367             str1 const s3(s2);
1368             BEAST_EXPECT(s3 == "x");
1369             BEAST_EXPECT(s3[0] == 'x');
1370             BEAST_EXPECT(s3.at(0) == 'x');
1371             BEAST_EXPECT(s3.front() == 'x');
1372             BEAST_EXPECT(s3.back() == 'x');
1373             s2 = "y";
1374             BEAST_EXPECT(s2 == "y");
1375             BEAST_EXPECT(s3 == "x");
1376             s1 = s2;
1377             BEAST_EXPECT(s1 == "y");
1378             s1.clear();
1379             BEAST_EXPECT(s1.empty());
1380             BEAST_EXPECT(s1.size() == 0);
1381         }
1382         {
1383             str2 s1("x");
1384             str1 s2(s1);
1385             BEAST_EXPECT(s2 == "x");
1386             str1 s3;
1387             s3 = s2;
1388             BEAST_EXPECT(s3 == "x");
1389             s1 = "xy";
1390             BEAST_EXPECT(s1.size() == 2);
1391             BEAST_EXPECT(s1[0] == 'x');
1392             BEAST_EXPECT(s1[1] == 'y');
1393             BEAST_EXPECT(s1.at(0) == 'x');
1394             BEAST_EXPECT(s1.at(1) == 'y');
1395             BEAST_EXPECT(s1.front() == 'x');
1396             BEAST_EXPECT(s1.back() == 'y');
1397             auto const s4 = s1;
1398             BEAST_EXPECT(s4[0] == 'x');
1399             BEAST_EXPECT(s4[1] == 'y');
1400             BEAST_EXPECT(s4.at(0) == 'x');
1401             BEAST_EXPECT(s4.at(1) == 'y');
1402             BEAST_EXPECT(s4.front() == 'x');
1403             BEAST_EXPECT(s4.back() == 'y');
1404             try
1405             {
1406                 s3 = s1;
1407                 fail();
1408             }
1409             catch(std::exception const&)
1410             {
1411                 pass();
1412             }
1413             try
1414             {
1415                 str1 s5(s1);
1416                 fail();
1417             }
1418             catch(std::exception const&)
1419             {
1420                 pass();
1421             }
1422         }
1423         {
1424             str1 s1("x");
1425             str2 s2;
1426             s2 = s1;
1427             try
1428             {
1429                 s1.resize(2);
1430                 fail();
1431             }
1432             catch(std::length_error const&)
1433             {
1434                 pass();
1435             }
1436         }
1437         pass();
1438     }
1439
1440     void
1441     testToStaticString()
1442     {
1443         BEAST_EXPECT(to_static_string<long>(0) == "0");
1444         BEAST_EXPECT(to_static_string<long>(1) == "1");
1445         BEAST_EXPECT(to_static_string<long>(0xffff) == "65535");
1446         BEAST_EXPECT(to_static_string<long>(0x10000) == "65536");
1447         BEAST_EXPECT(to_static_string<long long>(0xffffffff) == "4294967295");
1448
1449         BEAST_EXPECT(to_static_string<long>(-1) == "-1");
1450         BEAST_EXPECT(to_static_string<long>(-65535) == "-65535");
1451         BEAST_EXPECT(to_static_string<long>(-65536) == "-65536");
1452         BEAST_EXPECT(to_static_string<long long>(-4294967295ll) == "-4294967295");
1453
1454         BEAST_EXPECT(to_static_string<unsigned long>(0) == "0");
1455         BEAST_EXPECT(to_static_string<unsigned long>(1) == "1");
1456         BEAST_EXPECT(to_static_string<unsigned long>(0xffff) == "65535");
1457         BEAST_EXPECT(to_static_string<unsigned long>(0x10000) == "65536");
1458         BEAST_EXPECT(to_static_string<unsigned long>(0xffffffff) == "4294967295");
1459     }
1460
1461     void
1462     run() override
1463     {
1464         testConstruct();
1465         testAssign();
1466         testAccess();
1467         testIterators();
1468         testCapacity();
1469         testOperations();
1470         testCompare();
1471         testSwap();
1472
1473         testGeneral();
1474         testToStaticString();
1475     }
1476 };
1477
1478 BEAST_DEFINE_TESTSUITE(beast,core,static_string);
1479
1480 } // beast
1481 } // boost