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

   1 //
   2 // Copyright (c) 2016-2017 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/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             static_string<7> s1("12345");
 573             s1.insert(2, 2, '_');
 574             BEAST_EXPECT(s1 == "12__345");
 575             BEAST_EXPECT(*s1.end() == 0);
 576             try
 577             {
 578                 static_string<6> s2("12345");
 579                 s2.insert(2, 2, '_');
 580                 fail("", __FILE__, __LINE__);
 581             }
 582             catch(std::length_error const&)
 583             {
 584                 pass();
 585             }
 586             try
 587             {
 588                 static_string<6> s2("12345");
 589                 s2.insert(6, 2, '_');
 590                 fail("", __FILE__, __LINE__);
 591             }
 592             catch(std::out_of_range const&)
 593             {
 594                 pass();
 595             }
 596         }
 597         {
 598             static_string<7> s1("12345");
 599             s1.insert(2, "__");
 600             BEAST_EXPECT(s1 == "12__345");
 601             BEAST_EXPECT(*s1.end() == 0);
 602             try
 603             {
 604                 static_string<6> s2("12345");
 605                 s2.insert(2, "__");
 606                 fail("", __FILE__, __LINE__);
 607             }
 608             catch(std::length_error const&)
 609             {
 610                 pass();
 611             }
 612             try
 613             {
 614                 static_string<6> s2("12345");
 615                 s2.insert(6, "__");
 616                 fail("", __FILE__, __LINE__);
 617             }
 618             catch(std::out_of_range const&)
 619             {
 620                 pass();
 621             }
 622         }
 623         {
 624             static_string<7> s1("12345");
 625             s1.insert(2, "TUV", 2);
 626             BEAST_EXPECT(s1 == "12TU345");
 627             BEAST_EXPECT(*s1.end() == 0);
 628             try
 629             {
 630                 static_string<6> s2("12345");
 631                 s2.insert(2, "TUV", 2);
 632                 fail("", __FILE__, __LINE__);
 633             }
 634             catch(std::length_error const&)
 635             {
 636                 pass();
 637             }
 638             try
 639             {
 640                 static_string<6> s2("12345");
 641                 s2.insert(6, "TUV", 2);
 642                 fail("", __FILE__, __LINE__);
 643             }
 644             catch(std::out_of_range const&)
 645             {
 646                 pass();
 647             }
 648         }
 649         {
 650             static_string<7> s1("12345");
 651             s1.insert(2, static_string<3>("TU"));
 652             BEAST_EXPECT(s1 == "12TU345");
 653             BEAST_EXPECT(*s1.end() == 0);
 654             try
 655             {
 656                 static_string<6> s2("12345");
 657                 s2.insert(2, static_string<3>("TUV"));
 658                 fail("", __FILE__, __LINE__);
 659             }
 660             catch(std::length_error const&)
 661             {
 662                 pass();
 663             }
 664             try
 665             {
 666                 static_string<6> s2("12345");
 667                 s2.insert(6, static_string<3>("TUV"));
 668                 fail("", __FILE__, __LINE__);
 669             }
 670             catch(std::out_of_range const&)
 671             {
 672                 pass();
 673             }
 674         }
 675         {
 676             static_string<7> s1("12345");
 677             s1.insert(2, static_string<3>("TUV"), 1);
 678             BEAST_EXPECT(s1 == "12UV345");
 679             BEAST_EXPECT(*s1.end() == 0);
 680             s1 = "12345";
 681             s1.insert(2, static_string<3>("TUV"), 1, 1);
 682             BEAST_EXPECT(s1 == "12U345");
 683             BEAST_EXPECT(*s1.end() == 0);
 684             try
 685             {
 686                 static_string<6> s2("12345");
 687                 s2.insert(2, static_string<3>("TUV"), 1, 2);
 688                 fail("", __FILE__, __LINE__);
 689             }
 690             catch(std::length_error const&)
 691             {
 692                 pass();
 693             }
 694             try
 695             {
 696                 static_string<6> s2("12345");
 697                 s2.insert(6, static_string<3>("TUV"), 1, 2);
 698                 fail("", __FILE__, __LINE__);
 699             }
 700             catch(std::out_of_range const&)
 701             {
 702                 pass();
 703             }
 704         }
 705         {
 706             static_string<4> s1("123");
 707             s1.insert(s1.begin() + 1, '_');
 708             BEAST_EXPECT(s1 == "1_23");
 709             BEAST_EXPECT(*s1.end() == 0);
 710             try
 711             {
 712                 static_string<3> s2("123");
 713                 s2.insert(s2.begin() + 1, '_');
 714                 fail("", __FILE__, __LINE__);
 715             }
 716             catch(std::length_error const&)
 717             {
 718                 pass();
 719             }
 720         }
 721         {
 722             static_string<4> s1("12");
 723             s1.insert(s1.begin() + 1, 2, '_');
 724             BEAST_EXPECT(s1 == "1__2");
 725             BEAST_EXPECT(*s1.end() == 0);
 726             try
 727             {
 728                 static_string<4> s2("123");
 729                 s2.insert(s2.begin() + 1, 2, ' ');
 730                 fail("", __FILE__, __LINE__);
 731             }
 732             catch(std::length_error const&)
 733             {
 734                 pass();
 735             }
 736         }
 737         {
 738             static_string<3> s1("123");
 739             static_string<5> s2("UV");
 740             s2.insert(s2.begin() + 1, s1.begin(), s1.end());
 741             BEAST_EXPECT(s2 == "U123V");
 742             BEAST_EXPECT(*s2.end() == 0);
 743             try
 744             {
 745                 static_string<4> s3("UV");
 746                 s3.insert(s3.begin() + 1, s1.begin(), s1.end());
 747                 fail("", __FILE__, __LINE__);
 748             }
 749             catch(std::length_error const&)
 750             {
 751                 pass();
 752             }
 753         }
 754         {
 755             static_string<5> s1("123");
 756             s1.insert(1, string_view("UV"));
 757             BEAST_EXPECT(s1 == "1UV23");
 758             BEAST_EXPECT(*s1.end() == 0);
 759             try
 760             {
 761                 static_string<4> s2("123");
 762                 s2.insert(1, string_view("UV"));
 763                 fail("", __FILE__, __LINE__);
 764             }
 765             catch(std::length_error const&)
 766             {
 767                 pass();
 768             }
 769             try
 770             {
 771                 static_string<5> s2("123");
 772                 s2.insert(5, string_view("UV"));
 773                 fail("", __FILE__, __LINE__);
 774             }
 775             catch(std::out_of_range const&)
 776             {
 777                 pass();
 778             }
 779         }
 780         {
 781             static_string<5> s1("123");
 782             s1.insert(1, std::string("UV"));
 783             BEAST_EXPECT(s1 == "1UV23");
 784             BEAST_EXPECT(*s1.end() == 0);
 785             try
 786             {
 787                 s1.insert(1, std::string("UV"));
 788                 fail("", __FILE__, __LINE__);
 789             }
 790             catch(std::length_error const&)
 791             {
 792                 pass();
 793             }
 794         }
 795         {
 796             static_string<6> s1("123");
 797             s1.insert(1, std::string("UVX"), 1);
 798             BEAST_EXPECT(s1 == "1VX23");
 799             BEAST_EXPECT(*s1.end() == 0);
 800             s1.insert(4, std::string("PQR"), 1, 1);
 801             BEAST_EXPECT(s1 == "1VX2Q3");
 802             BEAST_EXPECT(*s1.end() == 0);
 803             try
 804             {
 805                 s1.insert(4, std::string("PQR"), 1, 1);
 806                 fail("", __FILE__, __LINE__);
 807             }
 808             catch(std::length_error const&)
 809             {
 810                 pass();
 811             }
 812         }
 813
 814         //
 815         // erase
 816         //
 817
 818         {
 819             static_string<9> s1("123456789");
 820             BEAST_EXPECT(s1.erase(1, 1) == "13456789");
 821             BEAST_EXPECT(s1 == "13456789");
 822             BEAST_EXPECT(*s1.end() == 0);
 823             BEAST_EXPECT(s1.erase(5) == "13456");
 824             BEAST_EXPECT(s1 == "13456");
 825             BEAST_EXPECT(*s1.end() == 0);
 826             try
 827             {
 828                 s1.erase(7);
 829                 fail("", __FILE__, __LINE__);
 830             }
 831             catch(std::out_of_range const&)
 832             {
 833                 pass();
 834             }
 835         }
 836         {
 837             static_string<9> s1("123456789");
 838             BEAST_EXPECT(*s1.erase(s1.begin() + 5) == '7');
 839             BEAST_EXPECT(s1 == "12345789");
 840             BEAST_EXPECT(*s1.end() == 0);
 841         }
 842         {
 843             static_string<9> s1("123456789");
 844             BEAST_EXPECT(*s1.erase(
 845                 s1.begin() + 5, s1.begin() + 7) == '8');
 846             BEAST_EXPECT(s1 == "1234589");
 847             BEAST_EXPECT(*s1.end() == 0);
 848         }
 849
 850         //
 851         // push_back
 852         //
 853
 854         {
 855             static_string<3> s1("12");
 856             s1.push_back('3');
 857             BEAST_EXPECT(s1 == "123");
 858             try
 859             {
 860                 s1.push_back('4');
 861                 fail("", __FILE__, __LINE__);
 862             }
 863             catch(std::length_error const&)
 864             {
 865                 pass();
 866             }
 867             static_string<0> s2;
 868             try
 869             {
 870                 s2.push_back('_');
 871                 fail("", __FILE__, __LINE__);
 872             }
 873             catch(std::length_error const&)
 874             {
 875                 pass();
 876             }
 877         }
 878
 879         //
 880         // pop_back
 881         //
 882
 883         {
 884             static_string<3> s1("123");
 885             s1.pop_back();
 886             BEAST_EXPECT(s1 == "12");
 887             BEAST_EXPECT(*s1.end() == 0);
 888             s1.pop_back();
 889             BEAST_EXPECT(s1 == "1");
 890             BEAST_EXPECT(*s1.end() == 0);
 891             s1.pop_back();
 892             BEAST_EXPECT(s1.empty());
 893             BEAST_EXPECT(*s1.end() == 0);
 894         }
 895
 896         //
 897         // append
 898         //
 899
 900         {
 901             static_string<3> s1("1");
 902             s1.append(2, '_');
 903             BEAST_EXPECT(s1 == "1__");
 904             BEAST_EXPECT(*s1.end() == 0);
 905             try
 906             {
 907                 static_string<2> s2("1");
 908                 s2.append(2, '_');
 909                 fail("", __FILE__, __LINE__);
 910             }
 911             catch(std::length_error const&)
 912             {
 913                 pass();
 914             }
 915         }
 916         {
 917             static_string<2> s1("__");
 918             static_string<3> s2("1");
 919             s2.append(s1);
 920             BEAST_EXPECT(s2 == "1__");
 921             BEAST_EXPECT(*s2.end() == 0);
 922             try
 923             {
 924                 static_string<2> s3("1");
 925                 s3.append(s1);
 926                 fail("", __FILE__, __LINE__);
 927             }
 928             catch(std::length_error const&)
 929             {
 930                 pass();
 931             }
 932         }
 933         {
 934             static_string<3> s1("XYZ");
 935             static_string<4> s2("12");
 936             s2.append(s1, 1);
 937             BEAST_EXPECT(s2 == "12YZ");
 938             BEAST_EXPECT(*s2.end() == 0);
 939             static_string<3> s3("12");
 940             s3.append(s1, 1, 1);
 941             BEAST_EXPECT(s3 == "12Y");
 942             BEAST_EXPECT(*s3.end() == 0);
 943             try
 944             {
 945                 static_string<3> s4("12");
 946                 s4.append(s1, 3);
 947                 fail("", __FILE__, __LINE__);
 948             }
 949             catch(std::out_of_range const&)
 950             {
 951                 pass();
 952             }
 953             try
 954             {
 955                 static_string<3> s4("12");
 956                 s4.append(s1, 1);
 957                 fail("", __FILE__, __LINE__);
 958             }
 959             catch(std::length_error const&)
 960             {
 961                 pass();
 962             }
 963         }
 964         {
 965             static_string<4> s1("12");
 966             s1.append("XYZ", 2);
 967             BEAST_EXPECT(s1 == "12XY");
 968             BEAST_EXPECT(*s1.end() == 0);
 969             try
 970             {
 971                 static_string<3> s3("12");
 972                 s3.append("XYZ", 2);
 973                 fail("", __FILE__, __LINE__);
 974             }
 975             catch(std::length_error const&)
 976             {
 977                 pass();
 978             }
 979         }
 980         {
 981             static_string<5> s1("12");
 982             s1.append("XYZ");
 983             BEAST_EXPECT(s1 == "12XYZ");
 984             BEAST_EXPECT(*s1.end() == 0);
 985             try
 986             {
 987                 static_string<4> s2("12");
 988                 s2.append("XYZ");
 989                 fail("", __FILE__, __LINE__);
 990             }
 991             catch(std::length_error const&)
 992             {
 993                 pass();
 994             }
 995         }
 996         {
 997             static_string<3> s1("XYZ");
 998             static_string<5> s2("12");
 999             s2.append(s1.begin(), s1.end());
1000             BEAST_EXPECT(s2 == "12XYZ");
1001             BEAST_EXPECT(*s2.end() == 0);
1002             try
1003             {
1004                 static_string<4> s3("12");
1005                 s3.append(s1.begin(), s1.end());
1006                 fail("", __FILE__, __LINE__);
1007             }
1008             catch(std::length_error const&)
1009             {
1010                 pass();
1011             }
1012         }
1013         {
1014             static_string<5> s1("123");
1015             s1.append({'X', 'Y'});
1016             BEAST_EXPECT(s1 == "123XY");
1017             BEAST_EXPECT(*s1.end() == 0);
1018             try
1019             {
1020                 static_string<4> s2("123");
1021                 s2.append({'X', 'Y'});
1022                 fail("", __FILE__, __LINE__);
1023             }
1024             catch(std::length_error const&)
1025             {
1026                 pass();
1027             }
1028         }
1029         {
1030             string_view s1("XYZ");
1031             static_string<5> s2("12");
1032             s2.append(s1);
1033             BEAST_EXPECT(s2 == "12XYZ");
1034             BEAST_EXPECT(*s2.end() == 0);
1035             try
1036             {
1037                 static_string<4> s3("12");
1038                 s3.append(s1);
1039                 fail("", __FILE__, __LINE__);
1040             }
1041             catch(std::length_error const&)
1042             {
1043                 pass();
1044             }
1045         }
1046         {
1047             static_string<6> s1("123");
1048             s1.append(std::string("UVX"), 1);
1049             BEAST_EXPECT(s1 == "123VX");
1050             BEAST_EXPECT(*s1.end() == 0);
1051             s1.append(std::string("PQR"), 1, 1);
1052             BEAST_EXPECT(s1 == "123VXQ");
1053             BEAST_EXPECT(*s1.end() == 0);
1054             try
1055             {
1056                 static_string<3> s2("123");
1057                 s2.append(std::string("PQR"), 1, 1);
1058                 fail("", __FILE__, __LINE__);
1059             }
1060             catch(std::length_error const&)
1061             {
1062                 pass();
1063             }
1064         }
1065
1066         //
1067         // operator+=
1068         //
1069
1070         {
1071             static_string<2> s1("__");
1072             static_string<3> s2("1");
1073             s2 += s1;
1074             BEAST_EXPECT(s2 == "1__");
1075             BEAST_EXPECT(*s2.end() == 0);
1076             try
1077             {
1078                 static_string<2> s3("1");
1079                 s3 += s1;
1080                 fail("", __FILE__, __LINE__);
1081             }
1082             catch(std::length_error const&)
1083             {
1084                 pass();
1085             }
1086         }
1087         {
1088             static_string<3> s1("12");
1089             s1 += '3';
1090             BEAST_EXPECT(s1 == "123");
1091             try
1092             {
1093                 s1 += '4';
1094                 fail("", __FILE__, __LINE__);
1095             }
1096             catch(std::length_error const&)
1097             {
1098                 pass();
1099             }
1100         }
1101         {
1102             static_string<4> s1("12");
1103             s1 += "34";
1104             BEAST_EXPECT(s1 == "1234");
1105             try
1106             {
1107                 s1 += "5";
1108                 fail("", __FILE__, __LINE__);
1109             }
1110             catch(std::length_error const&)
1111             {
1112                 pass();
1113             }
1114         }
1115         {
1116             static_string<4> s1("12");
1117             s1 += {'3', '4'};
1118             BEAST_EXPECT(s1 == "1234");
1119             try
1120             {
1121                 s1 += {'5'};
1122                 fail("", __FILE__, __LINE__);
1123             }
1124             catch(std::length_error const&)
1125             {
1126                 pass();
1127             }
1128         }
1129         {
1130             string_view s1("34");
1131             static_string<4> s2("12");
1132             s2 += s1;
1133             BEAST_EXPECT(s2 == "1234");
1134             try
1135             {
1136                 s2 += s1;
1137                 fail("", __FILE__, __LINE__);
1138             }
1139             catch(std::length_error const&)
1140             {
1141                 pass();
1142             }
1143         }
1144     }
1145
1146     void
1147     testCompare()
1148     {
1149         using str1 = static_string<1>;
1150         using str2 = static_string<2>;
1151         {
1152             str1 s1;
1153             str2 s2;
1154             s1 = "1";
1155             s2 = "22";
1156             BEAST_EXPECT(s1.compare(s2) < 0);
1157             BEAST_EXPECT(s2.compare(s1) > 0);
1158             BEAST_EXPECT(s1 < "10");
1159             BEAST_EXPECT(s2 > "1");
1160             BEAST_EXPECT("10" > s1);
1161             BEAST_EXPECT("1" < s2);
1162             BEAST_EXPECT(s1 < "20");
1163             BEAST_EXPECT(s2 > "1");
1164             BEAST_EXPECT(s2 > "2");
1165         }
1166         {
1167             str2 s1("x");
1168             str2 s2("x");
1169             BEAST_EXPECT(s1 == s2);
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         }
1176         {
1177             str1 s1("x");
1178             str2 s2("x");
1179             BEAST_EXPECT(s1 == s2);
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         }
1186         {
1187             str2 s("x");
1188             BEAST_EXPECT(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("x" == s);
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         }
1201         {
1202             str2 s("x");
1203             BEAST_EXPECT(s <= "y");
1204             BEAST_EXPECT(s < "y");
1205             BEAST_EXPECT(s != "y");
1206             BEAST_EXPECT(! (s == "y"));
1207             BEAST_EXPECT(! (s >= "y"));
1208             BEAST_EXPECT(! (s > "x"));
1209             BEAST_EXPECT("y" >= s);
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         }
1216         {
1217             str1 s1("x");
1218             str2 s2("y");
1219             BEAST_EXPECT(s1 <= s2);
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         }
1226         {
1227             str1 s1("x");
1228             str2 s2("xx");
1229             BEAST_EXPECT(s1 < s2);
1230             BEAST_EXPECT(s2 > s1);
1231         }
1232         {
1233             str1 s1("x");
1234             str2 s2("yy");
1235             BEAST_EXPECT(s1 < s2);
1236             BEAST_EXPECT(s2 > s1);
1237         }
1238     }
1239
1240     void
1241     testSwap()
1242     {
1243         {
1244             static_string<3> s1("123");
1245             static_string<3> s2("XYZ");
1246             swap(s1, s2);
1247             BEAST_EXPECT(s1 == "XYZ");
1248             BEAST_EXPECT(*s1.end() == 0);
1249             BEAST_EXPECT(s2 == "123");
1250             BEAST_EXPECT(*s2.end() == 0);
1251             static_string<3> s3("UV");
1252             swap(s2, s3);
1253             BEAST_EXPECT(s2 == "UV");
1254             BEAST_EXPECT(*s2.end() == 0);
1255             BEAST_EXPECT(s3 == "123");
1256             BEAST_EXPECT(*s3.end() == 0);
1257         }
1258         {
1259             static_string<5> s1("123");
1260             static_string<7> s2("XYZ");
1261             swap(s1, s2);
1262             BEAST_EXPECT(s1 == "XYZ");
1263             BEAST_EXPECT(*s1.end() == 0);
1264             BEAST_EXPECT(s2 == "123");
1265             BEAST_EXPECT(*s2.end() == 0);
1266             static_string<3> s3("UV");
1267             swap(s2, s3);
1268             BEAST_EXPECT(s2 == "UV");
1269             BEAST_EXPECT(*s2.end() == 0);
1270             BEAST_EXPECT(s3 == "123");
1271             BEAST_EXPECT(*s3.end() == 0);
1272             try
1273             {
1274                 static_string<5> s4("12345");
1275                 static_string<3> s5("XYZ");
1276                 swap(s4, s5);
1277                 fail("", __FILE__, __LINE__);
1278             }
1279             catch(std::length_error const&)
1280             {
1281                 pass();
1282             }
1283             try
1284             {
1285                 static_string<3> s4("XYZ");
1286                 static_string<5> s5("12345");
1287                 swap(s4, s5);
1288                 fail("", __FILE__, __LINE__);
1289             }
1290             catch(std::length_error const&)
1291             {
1292                 pass();
1293             }
1294         }
1295     }
1296
1297     void
1298     testGeneral()
1299     {
1300         using str1 = static_string<1>;
1301         using str2 = static_string<2>;
1302         {
1303             str1 s1;
1304             BEAST_EXPECT(s1 == "");
1305             BEAST_EXPECT(s1.empty());
1306             BEAST_EXPECT(s1.size() == 0);
1307             BEAST_EXPECT(s1.max_size() == 1);
1308             BEAST_EXPECT(s1.capacity() == 1);
1309             BEAST_EXPECT(s1.begin() == s1.end());
1310             BEAST_EXPECT(s1.cbegin() == s1.cend());
1311             BEAST_EXPECT(s1.rbegin() == s1.rend());
1312             BEAST_EXPECT(s1.crbegin() == s1.crend());
1313             try
1314             {
1315                 BEAST_EXPECT(s1.at(0) == 0);
1316                 fail();
1317             }
1318             catch(std::exception const&)
1319             {
1320                 pass();
1321             }
1322             BEAST_EXPECT(s1.data()[0] == 0);
1323             BEAST_EXPECT(*s1.c_str() == 0);
1324             BEAST_EXPECT(std::distance(s1.begin(), s1.end()) == 0);
1325             BEAST_EXPECT(std::distance(s1.cbegin(), s1.cend()) == 0);
1326             BEAST_EXPECT(std::distance(s1.rbegin(), s1.rend()) == 0);
1327             BEAST_EXPECT(std::distance(s1.crbegin(), s1.crend()) == 0);
1328             BEAST_EXPECT(s1.compare(s1) == 0);
1329         }
1330         {
1331             str1 const s1;
1332             BEAST_EXPECT(s1 == "");
1333             BEAST_EXPECT(s1.empty());
1334             BEAST_EXPECT(s1.size() == 0);
1335             BEAST_EXPECT(s1.max_size() == 1);
1336             BEAST_EXPECT(s1.capacity() == 1);
1337             BEAST_EXPECT(s1.begin() == s1.end());
1338             BEAST_EXPECT(s1.cbegin() == s1.cend());
1339             BEAST_EXPECT(s1.rbegin() == s1.rend());
1340             BEAST_EXPECT(s1.crbegin() == s1.crend());
1341             try
1342             {
1343                 BEAST_EXPECT(s1.at(0) == 0);
1344                 fail();
1345             }
1346             catch(std::exception const&)
1347             {
1348                 pass();
1349             }
1350             BEAST_EXPECT(s1.data()[0] == 0);
1351             BEAST_EXPECT(*s1.c_str() == 0);
1352             BEAST_EXPECT(std::distance(s1.begin(), s1.end()) == 0);
1353             BEAST_EXPECT(std::distance(s1.cbegin(), s1.cend()) == 0);
1354             BEAST_EXPECT(std::distance(s1.rbegin(), s1.rend()) == 0);
1355             BEAST_EXPECT(std::distance(s1.crbegin(), s1.crend()) == 0);
1356             BEAST_EXPECT(s1.compare(s1) == 0);
1357         }
1358         {
1359             str1 s1;
1360             str1 s2("x");
1361             BEAST_EXPECT(s2 == "x");
1362             BEAST_EXPECT(s2[0] == 'x');
1363             BEAST_EXPECT(s2.at(0) == 'x');
1364             BEAST_EXPECT(s2.front() == 'x');
1365             BEAST_EXPECT(s2.back() == 'x');
1366             str1 const s3(s2);
1367             BEAST_EXPECT(s3 == "x");
1368             BEAST_EXPECT(s3[0] == 'x');
1369             BEAST_EXPECT(s3.at(0) == 'x');
1370             BEAST_EXPECT(s3.front() == 'x');
1371             BEAST_EXPECT(s3.back() == 'x');
1372             s2 = "y";
1373             BEAST_EXPECT(s2 == "y");
1374             BEAST_EXPECT(s3 == "x");
1375             s1 = s2;
1376             BEAST_EXPECT(s1 == "y");
1377             s1.clear();
1378             BEAST_EXPECT(s1.empty());
1379             BEAST_EXPECT(s1.size() == 0);
1380         }
1381         {
1382             str2 s1("x");
1383             str1 s2(s1);
1384             BEAST_EXPECT(s2 == "x");
1385             str1 s3;
1386             s3 = s2;
1387             BEAST_EXPECT(s3 == "x");
1388             s1 = "xy";
1389             BEAST_EXPECT(s1.size() == 2);
1390             BEAST_EXPECT(s1[0] == 'x');
1391             BEAST_EXPECT(s1[1] == 'y');
1392             BEAST_EXPECT(s1.at(0) == 'x');
1393             BEAST_EXPECT(s1.at(1) == 'y');
1394             BEAST_EXPECT(s1.front() == 'x');
1395             BEAST_EXPECT(s1.back() == 'y');
1396             auto const s4 = s1;
1397             BEAST_EXPECT(s4[0] == 'x');
1398             BEAST_EXPECT(s4[1] == 'y');
1399             BEAST_EXPECT(s4.at(0) == 'x');
1400             BEAST_EXPECT(s4.at(1) == 'y');
1401             BEAST_EXPECT(s4.front() == 'x');
1402             BEAST_EXPECT(s4.back() == 'y');
1403             try
1404             {
1405                 s3 = s1;
1406                 fail();
1407             }
1408             catch(std::exception const&)
1409             {
1410                 pass();
1411             }
1412             try
1413             {
1414                 str1 s5(s1);
1415                 fail();
1416             }
1417             catch(std::exception const&)
1418             {
1419                 pass();
1420             }
1421         }
1422         {
1423             str1 s1("x");
1424             str2 s2;
1425             s2 = s1;
1426             try
1427             {
1428                 s1.resize(2);
1429                 fail();
1430             }
1431             catch(std::length_error const&)
1432             {
1433                 pass();
1434             }
1435         }
1436         pass();
1437     }
1438
1439     void
1440     testToStaticString()
1441     {
1442         BEAST_EXPECT(to_static_string<long>(0) == "0");
1443         BEAST_EXPECT(to_static_string<long>(1) == "1");
1444         BEAST_EXPECT(to_static_string<long>(0xffff) == "65535");
1445         BEAST_EXPECT(to_static_string<long>(0x10000) == "65536");
1446         BEAST_EXPECT(to_static_string<long long>(0xffffffff) == "4294967295");
1447
1448         BEAST_EXPECT(to_static_string<long>(-1) == "-1");
1449         BEAST_EXPECT(to_static_string<long>(-65535) == "-65535");
1450         BEAST_EXPECT(to_static_string<long>(-65536) == "-65536");
1451         BEAST_EXPECT(to_static_string<long long>(-4294967295ll) == "-4294967295");
1452
1453         BEAST_EXPECT(to_static_string<unsigned long>(0) == "0");
1454         BEAST_EXPECT(to_static_string<unsigned long>(1) == "1");
1455         BEAST_EXPECT(to_static_string<unsigned long>(0xffff) == "65535");
1456         BEAST_EXPECT(to_static_string<unsigned long>(0x10000) == "65536");
1457         BEAST_EXPECT(to_static_string<unsigned long>(0xffffffff) == "4294967295");
1458     }
1459
1460     void
1461     run() override
1462     {
1463         testConstruct();
1464         testAssign();
1465         testAccess();
1466         testIterators();
1467         testCapacity();
1468         testOperations();
1469         testCompare();
1470         testSwap();
1471
1472         testGeneral();
1473         testToStaticString();
1474     }
1475 };
1476
1477 BEAST_DEFINE_TESTSUITE(beast,core,static_string);
1478
1479 } // beast
1480 } // boost