folly/io/test/IOBufQueueTest.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <folly/io/IOBufQueue.h>
  18
  19 #include <iostream>
  20 #include <stdexcept>
  21 #include <string.h>
  22
  23 #include <folly/Range.h>
  24 #include <folly/portability/GTest.h>
  25
  26 using folly::IOBuf;
  27 using folly::IOBufQueue;
  28 using folly::StringPiece;
  29 using std::pair;
  30 using std::string;
  31 using std::unique_ptr;
  32
  33 // String Comma Length macro for string literals
  34 #define SCL(x) (x), sizeof(x) - 1
  35
  36 namespace {
  37
  38 IOBufQueue::Options clOptions;
  39 struct Initializer {
  40   Initializer() {
  41     clOptions.cacheChainLength = true;
  42   }
  43 };
  44 Initializer initializer;
  45
  46 unique_ptr<IOBuf> stringToIOBuf(const char* s, size_t len) {
  47   unique_ptr<IOBuf> buf = IOBuf::create(len);
  48   memcpy(buf->writableTail(), s, len);
  49   buf->append(len);
  50   return buf;
  51 }
  52
  53 void checkConsistency(const IOBufQueue& queue) {
  54   if (queue.options().cacheChainLength) {
  55     size_t len = queue.front() ? queue.front()->computeChainDataLength() : 0;
  56     EXPECT_EQ(len, queue.chainLength());
  57   }
  58 }
  59
  60 }
  61
  62 TEST(IOBufQueue, Simple) {
  63   IOBufQueue queue(clOptions);
  64   EXPECT_EQ(nullptr, queue.front());
  65   queue.append(SCL(""));
  66   EXPECT_EQ(nullptr, queue.front());
  67   queue.append(unique_ptr<IOBuf>());
  68   EXPECT_EQ(nullptr, queue.front());
  69   string emptyString;
  70   queue.append(emptyString);
  71   EXPECT_EQ(nullptr, queue.front());
  72 }
  73
  74 TEST(IOBufQueue, Append) {
  75   IOBufQueue queue(clOptions);
  76   queue.append(SCL("Hello"));
  77   IOBufQueue queue2(clOptions);
  78   queue2.append(SCL(", "));
  79   queue2.append(SCL("World"));
  80   checkConsistency(queue);
  81   checkConsistency(queue2);
  82   queue.append(queue2.move());
  83   checkConsistency(queue);
  84   checkConsistency(queue2);
  85   const IOBuf* chain = queue.front();
  86   EXPECT_NE((IOBuf*)nullptr, chain);
  87   EXPECT_EQ(12, chain->computeChainDataLength());
  88   EXPECT_EQ(nullptr, queue2.front());
  89 }
  90
  91 TEST(IOBufQueue, Append2) {
  92   IOBufQueue queue(clOptions);
  93   queue.append(SCL("Hello"));
  94   IOBufQueue queue2(clOptions);
  95   queue2.append(SCL(", "));
  96   queue2.append(SCL("World"));
  97   checkConsistency(queue);
  98   checkConsistency(queue2);
  99   queue.append(queue2);
 100   checkConsistency(queue);
 101   checkConsistency(queue2);
 102   const IOBuf* chain = queue.front();
 103   EXPECT_NE((IOBuf*)nullptr, chain);
 104   EXPECT_EQ(12, chain->computeChainDataLength());
 105   EXPECT_EQ(nullptr, queue2.front());
 106 }
 107
 108 TEST(IOBufQueue, AppendStringPiece) {
 109   std::string s("Hello, World");
 110   IOBufQueue queue(clOptions);
 111   IOBufQueue queue2(clOptions);
 112   queue.append(s.data(), s.length());
 113   queue2.append(s);
 114   checkConsistency(queue);
 115   checkConsistency(queue2);
 116   const IOBuf* chain = queue.front();
 117   const IOBuf* chain2 = queue2.front();
 118   EXPECT_EQ(s.length(), chain->computeChainDataLength());
 119   EXPECT_EQ(s.length(), chain2->computeChainDataLength());
 120   EXPECT_EQ(0, memcmp(chain->data(), chain2->data(), s.length()));
 121 }
 122
 123 TEST(IOBufQueue, Split) {
 124   IOBufQueue queue(clOptions);
 125   queue.append(stringToIOBuf(SCL("Hello")));
 126   queue.append(stringToIOBuf(SCL(",")));
 127   queue.append(stringToIOBuf(SCL(" ")));
 128   queue.append(stringToIOBuf(SCL("")));
 129   queue.append(stringToIOBuf(SCL("World")));
 130   checkConsistency(queue);
 131   EXPECT_EQ(12, queue.front()->computeChainDataLength());
 132
 133   unique_ptr<IOBuf> prefix(queue.split(1));
 134   checkConsistency(queue);
 135   EXPECT_EQ(1, prefix->computeChainDataLength());
 136   EXPECT_EQ(11, queue.front()->computeChainDataLength());
 137   prefix = queue.split(2);
 138   checkConsistency(queue);
 139   EXPECT_EQ(2, prefix->computeChainDataLength());
 140   EXPECT_EQ(9, queue.front()->computeChainDataLength());
 141   prefix = queue.split(3);
 142   checkConsistency(queue);
 143   EXPECT_EQ(3, prefix->computeChainDataLength());
 144   EXPECT_EQ(6, queue.front()->computeChainDataLength());
 145   prefix = queue.split(1);
 146   checkConsistency(queue);
 147   EXPECT_EQ(1, prefix->computeChainDataLength());
 148   EXPECT_EQ(5, queue.front()->computeChainDataLength());
 149   prefix = queue.split(5);
 150   checkConsistency(queue);
 151   EXPECT_EQ(5, prefix->computeChainDataLength());
 152   EXPECT_EQ((IOBuf*)nullptr, queue.front());
 153
 154   queue.append(stringToIOBuf(SCL("Hello,")));
 155   queue.append(stringToIOBuf(SCL(" World")));
 156   checkConsistency(queue);
 157   EXPECT_THROW({prefix = queue.split(13);}, std::underflow_error);
 158   checkConsistency(queue);
 159 }
 160
 161 TEST(IOBufQueue, SplitAtMost) {
 162   IOBufQueue queue(clOptions);
 163   queue.append(stringToIOBuf(SCL("Hello,")));
 164   queue.append(stringToIOBuf(SCL(" World")));
 165   auto buf = queue.splitAtMost(9999);
 166   EXPECT_EQ(buf->computeChainDataLength(), 12);
 167   EXPECT_TRUE(queue.empty());
 168 }
 169
 170 TEST(IOBufQueue, Preallocate) {
 171   IOBufQueue queue(clOptions);
 172   queue.append(string("Hello"));
 173   pair<void*,uint32_t> writable = queue.preallocate(2, 64, 64);
 174   checkConsistency(queue);
 175   EXPECT_NE((void*)nullptr, writable.first);
 176   EXPECT_LE(2, writable.second);
 177   EXPECT_GE(64, writable.second);
 178   memcpy(writable.first, SCL(", "));
 179   queue.postallocate(2);
 180   checkConsistency(queue);
 181   EXPECT_EQ(7, queue.front()->computeChainDataLength());
 182   queue.append(SCL("World"));
 183   checkConsistency(queue);
 184   EXPECT_EQ(12, queue.front()->computeChainDataLength());
 185   // There are not 2048 bytes available, this will alloc a new buf
 186   writable = queue.preallocate(2048, 4096);
 187   checkConsistency(queue);
 188   EXPECT_LE(2048, writable.second);
 189   // IOBuf allocates more than newAllocationSize, and we didn't cap it
 190   EXPECT_GE(writable.second, 4096);
 191   queue.postallocate(writable.second);
 192   // queue has no empty space, make sure we allocate at least min, even if
 193   // newAllocationSize < min
 194   writable = queue.preallocate(1024, 1, 1024);
 195   checkConsistency(queue);
 196   EXPECT_EQ(1024, writable.second);
 197 }
 198
 199 TEST(IOBufQueue, Wrap) {
 200   IOBufQueue queue(clOptions);
 201   const char* buf = "hello world goodbye";
 202   size_t len = strlen(buf);
 203   queue.wrapBuffer(buf, len, 6);
 204   auto iob = queue.move();
 205   EXPECT_EQ((len - 1) / 6 + 1, iob->countChainElements());
 206   iob->unshare();
 207   iob->coalesce();
 208   EXPECT_EQ(StringPiece(buf),
 209             StringPiece(reinterpret_cast<const char*>(iob->data()),
 210                         iob->length()));
 211 }
 212
 213 TEST(IOBufQueue, Trim) {
 214   IOBufQueue queue(clOptions);
 215   unique_ptr<IOBuf> a = IOBuf::create(4);
 216   a->append(4);
 217   queue.append(std::move(a));
 218   checkConsistency(queue);
 219   a = IOBuf::create(6);
 220   a->append(6);
 221   queue.append(std::move(a));
 222   checkConsistency(queue);
 223   a = IOBuf::create(8);
 224   a->append(8);
 225   queue.append(std::move(a));
 226   checkConsistency(queue);
 227   a = IOBuf::create(10);
 228   a->append(10);
 229   queue.append(std::move(a));
 230   checkConsistency(queue);
 231
 232   EXPECT_EQ(4, queue.front()->countChainElements());
 233   EXPECT_EQ(28, queue.front()->computeChainDataLength());
 234   EXPECT_EQ(4, queue.front()->length());
 235
 236   queue.trimStart(1);
 237   checkConsistency(queue);
 238   EXPECT_EQ(4, queue.front()->countChainElements());
 239   EXPECT_EQ(27, queue.front()->computeChainDataLength());
 240   EXPECT_EQ(3, queue.front()->length());
 241
 242   queue.trimStart(5);
 243   checkConsistency(queue);
 244   EXPECT_EQ(3, queue.front()->countChainElements());
 245   EXPECT_EQ(22, queue.front()->computeChainDataLength());
 246   EXPECT_EQ(4, queue.front()->length());
 247
 248   queue.trimEnd(1);
 249   checkConsistency(queue);
 250   EXPECT_EQ(3, queue.front()->countChainElements());
 251   EXPECT_EQ(21, queue.front()->computeChainDataLength());
 252   EXPECT_EQ(9, queue.front()->prev()->length());
 253
 254   queue.trimEnd(20);
 255   checkConsistency(queue);
 256   EXPECT_EQ(1, queue.front()->countChainElements());
 257   EXPECT_EQ(1, queue.front()->computeChainDataLength());
 258   EXPECT_EQ(1, queue.front()->prev()->length());
 259
 260   queue.trimEnd(1);
 261   checkConsistency(queue);
 262   EXPECT_EQ(nullptr, queue.front());
 263
 264   EXPECT_THROW(queue.trimStart(2), std::underflow_error);
 265   checkConsistency(queue);
 266
 267   EXPECT_THROW(queue.trimEnd(30), std::underflow_error);
 268   checkConsistency(queue);
 269 }
 270
 271 TEST(IOBufQueue, TrimPack) {
 272   IOBufQueue queue(clOptions);
 273   unique_ptr<IOBuf> a = IOBuf::create(64);
 274   a->append(4);
 275   queue.append(std::move(a), true);
 276   checkConsistency(queue);
 277   a = IOBuf::create(6);
 278   a->append(6);
 279   queue.append(std::move(a), true);
 280   checkConsistency(queue);
 281   a = IOBuf::create(8);
 282   a->append(8);
 283   queue.append(std::move(a), true);
 284   checkConsistency(queue);
 285   a = IOBuf::create(10);
 286   a->append(10);
 287   queue.append(std::move(a), true);
 288   checkConsistency(queue);
 289
 290   EXPECT_EQ(1, queue.front()->countChainElements());
 291   EXPECT_EQ(28, queue.front()->computeChainDataLength());
 292   EXPECT_EQ(28, queue.front()->length());
 293
 294   queue.trimStart(1);
 295   checkConsistency(queue);
 296   EXPECT_EQ(1, queue.front()->countChainElements());
 297   EXPECT_EQ(27, queue.front()->computeChainDataLength());
 298   EXPECT_EQ(27, queue.front()->length());
 299
 300   queue.trimStart(5);
 301   checkConsistency(queue);
 302   EXPECT_EQ(1, queue.front()->countChainElements());
 303   EXPECT_EQ(22, queue.front()->computeChainDataLength());
 304   EXPECT_EQ(22, queue.front()->length());
 305
 306   queue.trimEnd(1);
 307   checkConsistency(queue);
 308   EXPECT_EQ(1, queue.front()->countChainElements());
 309   EXPECT_EQ(21, queue.front()->computeChainDataLength());
 310   EXPECT_EQ(21, queue.front()->prev()->length());
 311
 312   queue.trimEnd(20);
 313   checkConsistency(queue);
 314   EXPECT_EQ(1, queue.front()->countChainElements());
 315   EXPECT_EQ(1, queue.front()->computeChainDataLength());
 316   EXPECT_EQ(1, queue.front()->prev()->length());
 317
 318   queue.trimEnd(1);
 319   checkConsistency(queue);
 320   EXPECT_EQ(nullptr, queue.front());
 321
 322   EXPECT_THROW(queue.trimStart(2), std::underflow_error);
 323   checkConsistency(queue);
 324
 325   EXPECT_THROW(queue.trimEnd(30), std::underflow_error);
 326   checkConsistency(queue);
 327 }
 328
 329 TEST(IOBufQueue, Prepend) {
 330   folly::IOBufQueue queue;
 331
 332   auto buf = folly::IOBuf::create(10);
 333   buf->advance(5);
 334   queue.append(std::move(buf));
 335
 336   queue.append(SCL(" World"));
 337   queue.prepend(SCL("Hello"));
 338
 339   EXPECT_THROW(queue.prepend(SCL("x")), std::overflow_error);
 340
 341   auto out = queue.move();
 342   out->coalesce();
 343   EXPECT_EQ("Hello World",
 344             StringPiece(reinterpret_cast<const char*>(out->data()),
 345                         out->length()));
 346 }
 347
 348 TEST(IOBufQueue, PopFirst) {
 349   IOBufQueue queue(IOBufQueue::cacheChainLength());
 350   const char * strings[] = {
 351     "Hello",
 352     ",",
 353     " ",
 354     "",
 355     "World"
 356   };
 357
 358   const size_t numStrings=sizeof(strings)/sizeof(*strings);
 359   size_t chainLength = 0;
 360   for(size_t i = 0; i < numStrings; ++i) {
 361     queue.append(stringToIOBuf(strings[i], strlen(strings[i])));
 362     checkConsistency(queue);
 363     chainLength += strlen(strings[i]);
 364   }
 365
 366   unique_ptr<IOBuf> first;
 367   for(size_t i = 0; i < numStrings; ++i) {
 368     checkConsistency(queue);
 369     EXPECT_EQ(chainLength, queue.front()->computeChainDataLength());
 370     EXPECT_EQ(chainLength, queue.chainLength());
 371     first = queue.pop_front();
 372     chainLength-=strlen(strings[i]);
 373     EXPECT_EQ(strlen(strings[i]), first->computeChainDataLength());
 374   }
 375   checkConsistency(queue);
 376   EXPECT_EQ(chainLength, queue.chainLength());
 377
 378   EXPECT_EQ((IOBuf*)nullptr, queue.front());
 379   first = queue.pop_front();
 380   EXPECT_EQ((IOBuf*)nullptr, first.get());
 381
 382   checkConsistency(queue);
 383   EXPECT_EQ((IOBuf*)nullptr, queue.front());
 384   EXPECT_EQ(0, queue.chainLength());
 385 }
 386
 387 TEST(IOBufQueue, AppendToString) {
 388   IOBufQueue queue;
 389   queue.append("hello ", 6);
 390   queue.append("world", 5);
 391   std::string s;
 392   queue.appendToString(s);
 393   EXPECT_EQ("hello world", s);
 394 }
 395
 396 TEST(IOBufQueue, Gather) {
 397   IOBufQueue queue;
 398
 399   queue.append(stringToIOBuf(SCL("hello ")));
 400   queue.append(stringToIOBuf(SCL("world")));
 401
 402   EXPECT_EQ(queue.front()->length(), 6);
 403   queue.gather(11);
 404   EXPECT_EQ(queue.front()->length(), 11);
 405
 406   StringPiece s(
 407       reinterpret_cast<const char*>(queue.front()->data()),
 408       queue.front()->length());
 409   EXPECT_EQ("hello world", s);
 410 }