net/quic/iovector_test.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/iovector.h"
   6
   7 #include <string.h>
   8
   9 #include "base/logging.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 using std::string;
  13
  14 namespace net {
  15 namespace test {
  16 namespace {
  17
  18 const char* const test_data[] = {
  19   "test string 1, a medium size one.",
  20   "test string2",
  21   "test string      3, a looooooooooooong loooooooooooooooong string"
  22 };
  23
  24 TEST(IOVectorTest, CopyConstructor) {
  25   IOVector iov1;
  26   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
  27     iov1.Append(const_cast<char*>(test_data[i]), strlen(test_data[i]));
  28   }
  29   IOVector iov2 = iov1;
  30   EXPECT_EQ(iov2.Size(), iov1.Size());
  31   for (size_t i = 0; i < iov2.Size(); ++i) {
  32     EXPECT_TRUE(iov2.iovec()[i].iov_base == iov1.iovec()[i].iov_base);
  33     EXPECT_EQ(iov2.iovec()[i].iov_len, iov1.iovec()[i].iov_len);
  34   }
  35   EXPECT_EQ(iov2.TotalBufferSize(), iov1.TotalBufferSize());
  36 }
  37
  38 TEST(IOVectorTest, AssignmentOperator) {
  39   IOVector iov1;
  40   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
  41     iov1.Append(const_cast<char*>(test_data[i]), strlen(test_data[i]));
  42   }
  43   IOVector iov2;
  44   iov2.Append(const_cast<char*>("ephemeral string"), 16);
  45   // The following assignment results in a shallow copy;
  46   // both IOVectors point to the same underlying data.
  47   iov2 = iov1;
  48   EXPECT_EQ(iov2.Size(), iov1.Size());
  49   for (size_t i = 0; i < iov2.Size(); ++i) {
  50     EXPECT_TRUE(iov2.iovec()[i].iov_base == iov1.iovec()[i].iov_base);
  51     EXPECT_EQ(iov2.iovec()[i].iov_len, iov1.iovec()[i].iov_len);
  52   }
  53   EXPECT_EQ(iov2.TotalBufferSize(), iov1.TotalBufferSize());
  54 }
  55
  56 TEST(IOVectorTest, Append) {
  57   IOVector iov;
  58   int length = 0;
  59   const struct iovec* iov2 = iov.iovec();
  60
  61   ASSERT_EQ(0u, iov.Size());
  62   ASSERT_TRUE(iov2 == NULL);
  63   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
  64     const int str_len = strlen(test_data[i]);
  65     const int append_len = str_len / 2;
  66     // This should append a new block
  67     iov.Append(const_cast<char*>(test_data[i]), append_len);
  68     length += append_len;
  69     ASSERT_EQ(i + 1, static_cast<size_t>(iov.Size()));
  70     ASSERT_TRUE(iov.LastBlockEnd() == test_data[i] + append_len);
  71     // This should just lengthen the existing block.
  72     iov.Append(const_cast<char*>(test_data[i] + append_len),
  73                str_len - append_len);
  74     length += (str_len - append_len);
  75     ASSERT_EQ(i + 1, static_cast<size_t>(iov.Size()));
  76     ASSERT_TRUE(iov.LastBlockEnd() == test_data[i] + str_len);
  77   }
  78
  79   iov2 = iov.iovec();
  80   ASSERT_TRUE(iov2 != NULL);
  81   for (size_t i = 0; i < iov.Size(); ++i) {
  82     ASSERT_TRUE(test_data[i] == iov2[i].iov_base);
  83     ASSERT_EQ(strlen(test_data[i]), iov2[i].iov_len);
  84   }
  85 }
  86
  87 TEST(IOVectorTest, AppendIovec) {
  88   IOVector iov;
  89   const struct iovec test_iov[] = {
  90     {const_cast<char*>("foo"), 3},
  91     {const_cast<char*>("bar"), 3},
  92     {const_cast<char*>("buzzzz"), 6}
  93   };
  94   iov.AppendIovec(test_iov, ARRAYSIZE_UNSAFE(test_iov));
  95   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_iov); ++i) {
  96     EXPECT_EQ(test_iov[i].iov_base, iov.iovec()[i].iov_base);
  97     EXPECT_EQ(test_iov[i].iov_len, iov.iovec()[i].iov_len);
  98   }
  99
 100   // Test AppendIovecAtMostBytes.
 101   iov.Clear();
 102   // Stop in the middle of a block.
 103   EXPECT_EQ(5u, iov.AppendIovecAtMostBytes(test_iov, ARRAYSIZE_UNSAFE(test_iov),
 104                                            5));
 105   EXPECT_EQ(5u, iov.TotalBufferSize());
 106   iov.Append(static_cast<char*>(test_iov[1].iov_base) + 2, 1);
 107   // Make sure the boundary case, where max_bytes == size of block also works.
 108   EXPECT_EQ(6u, iov.AppendIovecAtMostBytes(&test_iov[2], 1, 6));
 109   ASSERT_LE(ARRAYSIZE_UNSAFE(test_iov), static_cast<size_t>(iov.Size()));
 110   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_iov); ++i) {
 111     EXPECT_EQ(test_iov[i].iov_base, iov.iovec()[i].iov_base);
 112     EXPECT_EQ(test_iov[i].iov_len, iov.iovec()[i].iov_len);
 113   }
 114 }
 115
 116 TEST(IOVectorTest, ConsumeHalfBlocks) {
 117   IOVector iov;
 118   int length = 0;
 119
 120   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 121     const int str_len = strlen(test_data[i]);
 122     iov.Append(const_cast<char*>(test_data[i]), str_len);
 123     length += str_len;
 124   }
 125   const char* endp = iov.LastBlockEnd();
 126   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 127     const struct iovec* iov2 = iov.iovec();
 128     const size_t str_len = strlen(test_data[i]);
 129     size_t tmp = str_len / 2;
 130
 131     ASSERT_TRUE(iov2 != NULL);
 132     ASSERT_TRUE(iov2[0].iov_base == test_data[i]);
 133     ASSERT_EQ(str_len, iov2[0].iov_len);
 134
 135     // Consume half of the first block.
 136     size_t consumed = iov.Consume(tmp);
 137     ASSERT_EQ(tmp, consumed);
 138     ASSERT_EQ(ARRAYSIZE_UNSAFE(test_data) - i, static_cast<size_t>(iov.Size()));
 139     iov2 = iov.iovec();
 140     ASSERT_TRUE(iov2 != NULL);
 141     ASSERT_TRUE(iov2[0].iov_base == test_data[i] + tmp);
 142     ASSERT_EQ(iov2[0].iov_len, str_len - tmp);
 143
 144     // Consume the rest of the first block
 145     consumed = iov.Consume(str_len - tmp);
 146     ASSERT_EQ(str_len - tmp, consumed);
 147     ASSERT_EQ(ARRAYSIZE_UNSAFE(test_data) - i - 1,
 148               static_cast<size_t>(iov.Size()));
 149     iov2 = iov.iovec();
 150     if (iov.Size() > 0) {
 151       ASSERT_TRUE(iov2 != NULL);
 152       ASSERT_TRUE(iov.LastBlockEnd() == endp);
 153     } else {
 154       ASSERT_TRUE(iov2 == NULL);
 155       ASSERT_TRUE(iov.LastBlockEnd() == NULL);
 156     }
 157   }
 158 }
 159
 160 TEST(IOVectorTest, ConsumeTwoAndHalfBlocks) {
 161   IOVector iov;
 162   int length = 0;
 163
 164   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 165     const int str_len = strlen(test_data[i]);
 166     iov.Append(const_cast<char*>(test_data[i]), str_len);
 167     length += str_len;
 168   }
 169   const size_t last_len = strlen(test_data[ARRAYSIZE_UNSAFE(test_data) - 1]);
 170   const size_t half_len = last_len / 2;
 171
 172   const char* endp = iov.LastBlockEnd();
 173   size_t consumed = iov.Consume(length - half_len);
 174   ASSERT_EQ(length - half_len, consumed);
 175   const struct iovec* iov2 = iov.iovec();
 176   ASSERT_TRUE(iov2 != NULL);
 177   ASSERT_EQ(1u, iov.Size());
 178   ASSERT_TRUE(iov2[0].iov_base ==
 179               test_data[ARRAYSIZE_UNSAFE(test_data) - 1] + last_len - half_len);
 180   ASSERT_EQ(half_len, iov2[0].iov_len);
 181   ASSERT_TRUE(iov.LastBlockEnd() == endp);
 182
 183   consumed = iov.Consume(half_len);
 184   ASSERT_EQ(half_len, consumed);
 185   iov2 = iov.iovec();
 186   ASSERT_EQ(0u, iov.Size());
 187   ASSERT_TRUE(iov2 == NULL);
 188   ASSERT_TRUE(iov.LastBlockEnd() == NULL);
 189 }
 190
 191 TEST(IOVectorTest, ConsumeTooMuch) {
 192   IOVector iov;
 193   int length = 0;
 194
 195   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 196     const int str_len = strlen(test_data[i]);
 197     iov.Append(const_cast<char*>(test_data[i]), str_len);
 198     length += str_len;
 199   }
 200
 201   int consumed = 0;
 202   consumed = iov.Consume(length);
 203   // TODO(rtenneti): enable when chromium supports EXPECT_DFATAL.
 204   /*
 205   EXPECT_DFATAL(
 206       {consumed = iov.Consume(length + 1);},
 207       "Attempting to consume 1 non-existent bytes.");
 208   */
 209   ASSERT_EQ(length, consumed);
 210   const struct iovec* iov2 = iov.iovec();
 211   ASSERT_EQ(0u, iov.Size());
 212   ASSERT_TRUE(iov2 == NULL);
 213   ASSERT_TRUE(iov.LastBlockEnd() == NULL);
 214 }
 215
 216 TEST(IOVectorTest, Clear) {
 217   IOVector iov;
 218   int length = 0;
 219
 220   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 221     const int str_len = strlen(test_data[i]);
 222     iov.Append(const_cast<char*>(test_data[i]), str_len);
 223     length += str_len;
 224   }
 225   const struct iovec* iov2 = iov.iovec();
 226   ASSERT_TRUE(iov2 != NULL);
 227   ASSERT_EQ(ARRAYSIZE_UNSAFE(test_data), static_cast<size_t>(iov.Size()));
 228
 229   iov.Clear();
 230   iov2 = iov.iovec();
 231   ASSERT_EQ(0u, iov.Size());
 232   ASSERT_TRUE(iov2 == NULL);
 233 }
 234
 235 TEST(IOVectorTest, Capacity) {
 236   IOVector iov;
 237   // Note: IOVector merges adjacent Appends() into a single iov.
 238   // Therefore, if we expect final size of iov to be 3, we must insure
 239   // that the items we are appending are not adjacent. To achieve that
 240   // we use use an array (a[1] provides a buffer between a[0] and b[0],
 241   // and makes them non-adjacent).
 242   char a[2], b[2], c[2];
 243   iov.Append(&a[0], 1);
 244   iov.Append(&b[0], 1);
 245   iov.Append(&c[0], 1);
 246   ASSERT_EQ(3u, iov.Size());
 247   size_t capacity = iov.Capacity();
 248   EXPECT_LE(iov.Size(), capacity);
 249   iov.Consume(2);
 250   // The capacity should not have changed.
 251   EXPECT_EQ(capacity, iov.Capacity());
 252 }
 253
 254 TEST(IOVectorTest, Swap) {
 255   IOVector iov1, iov2;
 256   // See IOVector merge comment above.
 257   char a[2], b[2], c[2], d[2], e[2];
 258   iov1.Append(&a[0], 1);
 259   iov1.Append(&b[0], 1);
 260
 261   iov2.Append(&c[0], 1);
 262   iov2.Append(&d[0], 1);
 263   iov2.Append(&e[0], 1);
 264   iov1.Swap(&iov2);
 265
 266   ASSERT_EQ(3u, iov1.Size());
 267   EXPECT_EQ(&c[0], iov1.iovec()[0].iov_base);
 268   EXPECT_EQ(1u, iov1.iovec()[0].iov_len);
 269   EXPECT_EQ(&d[0], iov1.iovec()[1].iov_base);
 270   EXPECT_EQ(1u, iov1.iovec()[1].iov_len);
 271   EXPECT_EQ(&e[0], iov1.iovec()[2].iov_base);
 272   EXPECT_EQ(1u, iov1.iovec()[2].iov_len);
 273
 274   ASSERT_EQ(2u, iov2.Size());
 275   EXPECT_EQ(&a[0], iov2.iovec()[0].iov_base);
 276   EXPECT_EQ(1u, iov2.iovec()[0].iov_len);
 277   EXPECT_EQ(&b[0], iov2.iovec()[1].iov_base);
 278   EXPECT_EQ(1u, iov2.iovec()[1].iov_len);
 279 }
 280
 281 }  // namespace
 282 }  // namespace test
 283 }  // namespace net