ceph/src/Beast/test/core/static_string.cpp

   1 //
   2 // Copyright (c) 2013-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
   8 // Test that header file is self-contained.
   9 #include <beast/core/static_string.hpp>
  10
  11 #include <beast/unit_test/suite.hpp>
  12
  13 namespace beast {
  14
  15 class static_string_test : public beast::unit_test::suite
  16 {
  17 public:
  18     void testMembers()
  19     {
  20         using str1 = static_string<1>;
  21         using str2 = static_string<2>;
  22         {
  23             str1 s1;
  24             BEAST_EXPECT(s1 == "");
  25             BEAST_EXPECT(s1.empty());
  26             BEAST_EXPECT(s1.size() == 0);
  27             BEAST_EXPECT(s1.max_size() == 1);
  28             BEAST_EXPECT(s1.capacity() == 1);
  29             BEAST_EXPECT(s1.begin() == s1.end());
  30             BEAST_EXPECT(s1.cbegin() == s1.cend());
  31             BEAST_EXPECT(s1.rbegin() == s1.rend());
  32             BEAST_EXPECT(s1.crbegin() == s1.crend());
  33             try
  34             {
  35                 BEAST_EXPECT(s1.at(0) == 0);
  36                 fail();
  37             }
  38             catch(std::exception const&)
  39             {
  40                 pass();
  41             }
  42             BEAST_EXPECT(s1.data()[0] == 0);
  43             BEAST_EXPECT(*s1.c_str() == 0);
  44             BEAST_EXPECT(std::distance(s1.begin(), s1.end()) == 0);
  45             BEAST_EXPECT(std::distance(s1.cbegin(), s1.cend()) == 0);
  46             BEAST_EXPECT(std::distance(s1.rbegin(), s1.rend()) == 0);
  47             BEAST_EXPECT(std::distance(s1.crbegin(), s1.crend()) == 0);
  48             BEAST_EXPECT(s1.compare(s1) == 0);
  49             BEAST_EXPECT(s1.to_string() == std::string{});
  50         }
  51         {
  52             str1 const s1;
  53             BEAST_EXPECT(s1 == "");
  54             BEAST_EXPECT(s1.empty());
  55             BEAST_EXPECT(s1.size() == 0);
  56             BEAST_EXPECT(s1.max_size() == 1);
  57             BEAST_EXPECT(s1.capacity() == 1);
  58             BEAST_EXPECT(s1.begin() == s1.end());
  59             BEAST_EXPECT(s1.cbegin() == s1.cend());
  60             BEAST_EXPECT(s1.rbegin() == s1.rend());
  61             BEAST_EXPECT(s1.crbegin() == s1.crend());
  62             try
  63             {
  64                 BEAST_EXPECT(s1.at(0) == 0);
  65                 fail();
  66             }
  67             catch(std::exception const&)
  68             {
  69                 pass();
  70             }
  71             BEAST_EXPECT(s1.data()[0] == 0);
  72             BEAST_EXPECT(*s1.c_str() == 0);
  73             BEAST_EXPECT(std::distance(s1.begin(), s1.end()) == 0);
  74             BEAST_EXPECT(std::distance(s1.cbegin(), s1.cend()) == 0);
  75             BEAST_EXPECT(std::distance(s1.rbegin(), s1.rend()) == 0);
  76             BEAST_EXPECT(std::distance(s1.crbegin(), s1.crend()) == 0);
  77             BEAST_EXPECT(s1.compare(s1) == 0);
  78             BEAST_EXPECT(s1.to_string() == std::string{});
  79         }
  80         {
  81             str1 s1;
  82             str1 s2("x");
  83             BEAST_EXPECT(s2 == "x");
  84             BEAST_EXPECT(s2[0] == 'x');
  85             BEAST_EXPECT(s2.at(0) == 'x');
  86             BEAST_EXPECT(s2.front() == 'x');
  87             BEAST_EXPECT(s2.back() == 'x');
  88             str1 const s3(s2);
  89             BEAST_EXPECT(s3 == "x");
  90             BEAST_EXPECT(s3[0] == 'x');
  91             BEAST_EXPECT(s3.at(0) == 'x');
  92             BEAST_EXPECT(s3.front() == 'x');
  93             BEAST_EXPECT(s3.back() == 'x');
  94             s2 = "y";
  95             BEAST_EXPECT(s2 == "y");
  96             BEAST_EXPECT(s3 == "x");
  97             s1 = s2;
  98             BEAST_EXPECT(s1 == "y");
  99             s1.clear();
 100             BEAST_EXPECT(s1.empty());
 101             BEAST_EXPECT(s1.size() == 0);
 102         }
 103         {
 104             str2 s1("x");
 105             str1 s2(s1);
 106             BEAST_EXPECT(s2 == "x");
 107             str1 s3;
 108             s3 = s2;
 109             BEAST_EXPECT(s3 == "x");
 110             s1 = "xy";
 111             BEAST_EXPECT(s1.size() == 2);
 112             BEAST_EXPECT(s1[0] == 'x');
 113             BEAST_EXPECT(s1[1] == 'y');
 114             BEAST_EXPECT(s1.at(0) == 'x');
 115             BEAST_EXPECT(s1.at(1) == 'y');
 116             BEAST_EXPECT(s1.front() == 'x');
 117             BEAST_EXPECT(s1.back() == 'y');
 118             auto const s4 = s1;
 119             BEAST_EXPECT(s4[0] == 'x');
 120             BEAST_EXPECT(s4[1] == 'y');
 121             BEAST_EXPECT(s4.at(0) == 'x');
 122             BEAST_EXPECT(s4.at(1) == 'y');
 123             BEAST_EXPECT(s4.front() == 'x');
 124             BEAST_EXPECT(s4.back() == 'y');
 125             try
 126             {
 127                 s3 = s1;
 128                 fail();
 129             }
 130             catch(std::exception const&)
 131             {
 132                 pass();
 133             }
 134             try
 135             {
 136                 str1 s5(s1);
 137                 fail();
 138             }
 139             catch(std::exception const&)
 140             {
 141                 pass();
 142             }
 143         }
 144         {
 145             str1 s1("x");
 146             str2 s2;
 147             s2 = s1;
 148             try
 149             {
 150                 s1.resize(2);
 151                 fail();
 152             }
 153             catch(std::length_error const&)
 154             {
 155                 pass();
 156             }
 157         }
 158         pass();
 159     }
 160
 161     void testCompare()
 162     {
 163         using str1 = static_string<1>;
 164         using str2 = static_string<2>;
 165         {
 166             str1 s1;
 167             str2 s2;
 168             s1 = "1";
 169             s2 = "22";
 170             BEAST_EXPECT(s1.compare(s2) < 0);
 171             BEAST_EXPECT(s2.compare(s1) > 0);
 172             BEAST_EXPECT(s1 < "10");
 173             BEAST_EXPECT(s2 > "1");
 174             BEAST_EXPECT("10" > s1);
 175             BEAST_EXPECT("1" < s2);
 176             BEAST_EXPECT(s1 < "20");
 177             BEAST_EXPECT(s2 > "1");
 178             BEAST_EXPECT(s2 > "2");
 179         }
 180         {
 181             str2 s1("x");
 182             str2 s2("x");
 183             BEAST_EXPECT(s1 == s2);
 184             BEAST_EXPECT(s1 <= s2);
 185             BEAST_EXPECT(s1 >= s2);
 186             BEAST_EXPECT(! (s1 < s2));
 187             BEAST_EXPECT(! (s1 > s2));
 188             BEAST_EXPECT(! (s1 != s2));
 189         }
 190         {
 191             str1 s1("x");
 192             str2 s2("x");
 193             BEAST_EXPECT(s1 == s2);
 194             BEAST_EXPECT(s1 <= s2);
 195             BEAST_EXPECT(s1 >= s2);
 196             BEAST_EXPECT(! (s1 < s2));
 197             BEAST_EXPECT(! (s1 > s2));
 198             BEAST_EXPECT(! (s1 != s2));
 199         }
 200         {
 201             str2 s("x");
 202             BEAST_EXPECT(s == "x");
 203             BEAST_EXPECT(s <= "x");
 204             BEAST_EXPECT(s >= "x");
 205             BEAST_EXPECT(! (s < "x"));
 206             BEAST_EXPECT(! (s > "x"));
 207             BEAST_EXPECT(! (s != "x"));
 208             BEAST_EXPECT("x" == s);
 209             BEAST_EXPECT("x" <= s);
 210             BEAST_EXPECT("x" >= s);
 211             BEAST_EXPECT(! ("x" < s));
 212             BEAST_EXPECT(! ("x" > s));
 213             BEAST_EXPECT(! ("x" != s));
 214         }
 215         {
 216             str2 s("x");
 217             BEAST_EXPECT(s <= "y");
 218             BEAST_EXPECT(s < "y");
 219             BEAST_EXPECT(s != "y");
 220             BEAST_EXPECT(! (s == "y"));
 221             BEAST_EXPECT(! (s >= "y"));
 222             BEAST_EXPECT(! (s > "x"));
 223             BEAST_EXPECT("y" >= s);
 224             BEAST_EXPECT("y" > s);
 225             BEAST_EXPECT("y" != s);
 226             BEAST_EXPECT(! ("y" == s));
 227             BEAST_EXPECT(! ("y" <= s));
 228             BEAST_EXPECT(! ("y" < s));
 229         }
 230         {
 231             str1 s1("x");
 232             str2 s2("y");
 233             BEAST_EXPECT(s1 <= s2);
 234             BEAST_EXPECT(s1 < s2);
 235             BEAST_EXPECT(s1 != s2);
 236             BEAST_EXPECT(! (s1 == s2));
 237             BEAST_EXPECT(! (s1 >= s2));
 238             BEAST_EXPECT(! (s1 > s2));
 239         }
 240         {
 241             str1 s1("x");
 242             str2 s2("xx");
 243             BEAST_EXPECT(s1 < s2);
 244             BEAST_EXPECT(s2 > s1);
 245         }
 246         {
 247             str1 s1("x");
 248             str2 s2("yy");
 249             BEAST_EXPECT(s1 < s2);
 250             BEAST_EXPECT(s2 > s1);
 251         }
 252     }
 253
 254     void run() override
 255     {
 256         testMembers();
 257         testCompare();
 258     }
 259 };
 260
 261 BEAST_DEFINE_TESTSUITE(static_string,core,beast);
 262
 263 } // beast