src/net/tools/balsa/balsa_headers_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/tools/balsa/balsa_headers.h"
   6
   7 #include <iterator>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/strings/string_piece.h"
  13 #include "net/tools/balsa/balsa_enums.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace net {
  17
  18 using ::base::StringPiece;
  19
  20 class BalsaBufferTest : public ::testing::Test {
  21  public:
  22   void SetUp() override {
  23     buffer_.reset(new BalsaBuffer);
  24     anotherBuffer_.reset(new BalsaBuffer);
  25   }
  26
  27  protected:
  28   scoped_ptr<BalsaBuffer> buffer_;
  29   scoped_ptr<BalsaBuffer> anotherBuffer_;
  30 };
  31
  32 namespace {
  33
  34 class BalsaHeadersTest: public ::testing::Test {
  35  public:
  36   void SetUp() override { headers_.reset(new BalsaHeaders); }
  37
  38  protected:
  39   scoped_ptr<BalsaHeaders> headers_;
  40 };
  41
  42 class StringBuffer {
  43  public:
  44   void Write(const char* p, size_t size) {
  45     string_ += std::string(p, size);
  46   }
  47   const std::string& string() {return string_;}
  48
  49  private:
  50   std::string string_;
  51 };
  52
  53 TEST_F(BalsaBufferTest, EmptyBuffer) {
  54   ASSERT_EQ(1u, buffer_->num_blocks());
  55 }
  56
  57 TEST_F(BalsaBufferTest, Write) {
  58   size_t index1, index2;
  59   StringPiece sp1 = buffer_->Write(StringPiece("hello"), &index1);
  60   StringPiece sp2 = buffer_->Write(StringPiece(", world"), &index2);
  61
  62   ASSERT_EQ(2u, buffer_->num_blocks());
  63   ASSERT_EQ("hello", sp1);
  64   ASSERT_EQ(", world", sp2);
  65   ASSERT_EQ(1u, index1);
  66   ASSERT_EQ(1u, index2);
  67   ASSERT_EQ("hello, world",
  68             StringPiece(buffer_->GetPtr(1), buffer_->bytes_used(1)));
  69 }
  70
  71 TEST_F(BalsaBufferTest, WriteLongData) {
  72   size_t index1, index2, index3;
  73   std::string as(2, 'a');
  74   std::string bs(BalsaBuffer::kDefaultBlocksize + 1, 'b');
  75   std::string cs(4, 'c');
  76
  77   StringPiece sp1 = buffer_->Write(as, &index1);
  78   StringPiece sp2 = buffer_->Write(bs, &index2);
  79   StringPiece sp3 = buffer_->Write(cs, &index3);
  80
  81   ASSERT_EQ(3u, buffer_->num_blocks());
  82   ASSERT_EQ(as, sp1);
  83   ASSERT_EQ(bs, sp2);
  84   ASSERT_EQ(cs, sp3);
  85   ASSERT_EQ(1u, index1);
  86   ASSERT_EQ(2u, index2);
  87   ASSERT_EQ(1u, index3);
  88   ASSERT_EQ("aacccc", StringPiece(buffer_->GetPtr(1), buffer_->bytes_used(1)));
  89   ASSERT_EQ(sp2, StringPiece(buffer_->GetPtr(2), buffer_->bytes_used(2)));
  90 }
  91
  92 TEST_F(BalsaBufferTest, WriteToContiguousBuffer) {
  93   std::string as(2, 'a');
  94   std::string bs(BalsaBuffer::kDefaultBlocksize + 1, 'b');
  95   std::string cs(4, 'c');
  96
  97   buffer_->WriteToContiguousBuffer(as);
  98   buffer_->WriteToContiguousBuffer(bs);
  99   buffer_->WriteToContiguousBuffer(cs);
 100
 101   ASSERT_EQ(1u, buffer_->num_blocks());
 102   ASSERT_EQ(as + bs + cs,
 103             StringPiece(buffer_->GetPtr(0), buffer_->bytes_used(0)));
 104 }
 105
 106 TEST_F(BalsaBufferTest, NoMoreWriteToContiguousBuffer) {
 107   size_t index1, index2;
 108   StringPiece sp1 = buffer_->Write(StringPiece("hello"), &index1);
 109   buffer_->NoMoreWriteToContiguousBuffer();
 110   StringPiece sp2 = buffer_->Write(StringPiece(", world"), &index2);
 111
 112   ASSERT_EQ(2u, buffer_->num_blocks());
 113   ASSERT_EQ("hello", sp1);
 114   ASSERT_EQ(", world", sp2);
 115   ASSERT_EQ(1u, index1);
 116   ASSERT_EQ(0u, index2);
 117   ASSERT_EQ(sp1, StringPiece(buffer_->GetPtr(1), buffer_->bytes_used(1)));
 118   ASSERT_EQ(sp2, StringPiece(buffer_->GetPtr(0), buffer_->bytes_used(0)));
 119 }
 120
 121 TEST_F(BalsaBufferTest, Clear) {
 122   buffer_->Write("hello", NULL);
 123   ASSERT_EQ(2u, buffer_->num_blocks());
 124   buffer_->Clear();
 125   ASSERT_EQ(1u, buffer_->num_blocks());
 126 }
 127
 128 TEST_F(BalsaBufferTest, Swap) {
 129   buffer_->Write("hello", NULL);
 130
 131   ASSERT_EQ(2u, buffer_->num_blocks());
 132   ASSERT_EQ(1u, anotherBuffer_->num_blocks());
 133
 134   buffer_->Swap(anotherBuffer_.get());
 135
 136   ASSERT_EQ(1u, buffer_->num_blocks());
 137   ASSERT_EQ(2u, anotherBuffer_->num_blocks());
 138   ASSERT_EQ("hello",
 139             StringPiece(anotherBuffer_->GetPtr(1),
 140                         anotherBuffer_->bytes_used(1)));
 141 }
 142
 143 TEST_F(BalsaBufferTest, CopyFrom) {
 144   buffer_->Write("hello", NULL);
 145
 146   ASSERT_EQ(2u, buffer_->num_blocks());
 147   ASSERT_EQ(1u, anotherBuffer_->num_blocks());
 148
 149   anotherBuffer_->CopyFrom(*buffer_);
 150
 151   ASSERT_EQ(2u, buffer_->num_blocks());
 152   ASSERT_EQ(2u, anotherBuffer_->num_blocks());
 153   ASSERT_EQ("hello", StringPiece(buffer_->GetPtr(1), buffer_->bytes_used(1)));
 154   ASSERT_EQ("hello",
 155             StringPiece(anotherBuffer_->GetPtr(1),
 156                         anotherBuffer_->bytes_used(1)));
 157 }
 158
 159 TEST_F(BalsaHeadersTest, AppendHeader) {
 160   headers_->AppendHeader("key1", "value1");
 161   headers_->AppendHeader("key2", "value2");
 162   headers_->AppendHeader("key3", "value3");
 163   headers_->AppendHeader("key3", "value3.1");
 164   headers_->AppendHeader("key3", "value3.2");
 165
 166   ASSERT_EQ(5, std::distance(headers_->header_lines_begin(),
 167                              headers_->header_lines_end()));
 168   ASSERT_EQ("value1", headers_->GetHeader("key1"));
 169   ASSERT_EQ("value2", headers_->GetHeader("key2"));
 170   ASSERT_EQ("value3", headers_->GetHeader("key3"));
 171
 172   std::vector<base::StringPiece> v1, v2, v3;
 173   std::string s1, s2, s3;
 174   headers_->GetAllOfHeader("key1", &v1);
 175   headers_->GetAllOfHeader("key2", &v2);
 176   headers_->GetAllOfHeader("key3", &v3);
 177   headers_->GetAllOfHeaderAsString("key1", &s1);
 178   headers_->GetAllOfHeaderAsString("key2", &s2);
 179   headers_->GetAllOfHeaderAsString("key3", &s3);
 180
 181   ASSERT_EQ(1u, v1.size());
 182   ASSERT_EQ(1u, v2.size());
 183   ASSERT_EQ(3u, v3.size());
 184   ASSERT_EQ("value1", v1[0]);
 185   ASSERT_EQ("value2", v2[0]);
 186   ASSERT_EQ("value3", v3[0]);
 187   ASSERT_EQ("value3.1", v3[1]);
 188   ASSERT_EQ("value3.2", v3[2]);
 189   ASSERT_EQ("value1", s1);
 190   ASSERT_EQ("value2", s2);
 191   ASSERT_EQ("value3,value3.1,value3.2", s3);
 192 }
 193
 194 TEST_F(BalsaHeadersTest, ReplaceOrAppendHeader) {
 195   headers_->ReplaceOrAppendHeader("key1", "value1");
 196   headers_->ReplaceOrAppendHeader("key1", "value2");
 197
 198   ASSERT_EQ(1, std::distance(headers_->header_lines_begin(),
 199                              headers_->header_lines_end()));
 200   ASSERT_EQ("value2", headers_->GetHeader("key1"));
 201
 202   std::vector<base::StringPiece> v;
 203   headers_->GetAllOfHeader("key1", &v);
 204
 205   ASSERT_EQ(1u, v.size());
 206   ASSERT_EQ("value2", v[0]);
 207 }
 208
 209 TEST_F(BalsaHeadersTest, AppendToHeader) {
 210   headers_->AppendToHeader("key1", "value1");
 211   headers_->AppendToHeader("keY1", "value2");
 212
 213   ASSERT_EQ(1, std::distance(headers_->header_lines_begin(),
 214                              headers_->header_lines_end()));
 215   ASSERT_EQ("value1,value2", headers_->GetHeader("key1"));
 216
 217   std::vector<base::StringPiece> v;
 218   std::string s;
 219   headers_->GetAllOfHeader("key1", &v);
 220   headers_->GetAllOfHeaderAsString("keY1", &s);
 221
 222   ASSERT_EQ(1u, v.size());
 223   ASSERT_EQ("value1,value2", v[0]);
 224   ASSERT_EQ("value1,value2", s);
 225 }
 226
 227 TEST_F(BalsaHeadersTest, PrepentToHeader) {
 228   headers_->PrependToHeader("key1", "value1");
 229   headers_->PrependToHeader("key1", "value2");
 230
 231   ASSERT_EQ(1, std::distance(headers_->header_lines_begin(),
 232                              headers_->header_lines_end()));
 233   ASSERT_EQ("value2,value1", headers_->GetHeader("key1"));
 234
 235   std::vector<base::StringPiece> v;
 236   std::string s;
 237   headers_->GetAllOfHeader("key1", &v);
 238   headers_->GetAllOfHeaderAsString("key1", &s);
 239
 240   ASSERT_EQ(1u, v.size());
 241   ASSERT_EQ("value2,value1", v[0]);
 242   ASSERT_EQ("value2,value1", s);
 243 }
 244
 245 TEST_F(BalsaHeadersTest, HasHeader) {
 246   headers_->AppendHeader("key1", "value1");
 247
 248   ASSERT_TRUE(headers_->HasHeader("key1"));
 249   ASSERT_FALSE(headers_->HasHeader("value1"));
 250   ASSERT_FALSE(headers_->HasHeader("key2"));
 251 }
 252
 253 TEST_F(BalsaHeadersTest, HasNonEmptyHeader) {
 254   headers_->AppendHeader("key1", "value1");
 255   headers_->AppendHeader("key2", "");
 256
 257   ASSERT_TRUE(headers_->HasNonEmptyHeader("key1"));
 258   ASSERT_FALSE(headers_->HasNonEmptyHeader("key2"));
 259   ASSERT_FALSE(headers_->HasNonEmptyHeader("key3"));
 260 }
 261
 262 TEST_F(BalsaHeadersTest, GetHeaderPosition) {
 263   headers_->AppendHeader("key1", "value1");
 264   headers_->AppendHeader("key2", "value2");
 265   headers_->AppendHeader("key3", "value3");
 266
 267   BalsaHeaders::const_header_lines_iterator i =
 268       headers_->GetHeaderPosition("key2");
 269
 270   ASSERT_EQ(headers_->header_lines_end(),
 271             headers_->GetHeaderPosition("foobar"));
 272   ASSERT_EQ(headers_->header_lines_begin(),
 273             headers_->GetHeaderPosition("key1"));
 274   ASSERT_NE(headers_->header_lines_end(), i);
 275   ASSERT_EQ("key2", i->first);
 276   ASSERT_EQ("value2", i->second);
 277   ++i;
 278   ASSERT_EQ("key3", i->first);
 279   ASSERT_EQ("value3", i->second);
 280   ++i;
 281   ASSERT_EQ(headers_->header_lines_end(), i);
 282 }
 283
 284 TEST_F(BalsaHeadersTest, GetIteratorForKey) {
 285   headers_->AppendHeader("key1", "value1");
 286   headers_->AppendHeader("key2", "value2");
 287   headers_->AppendHeader("key1", "value1.1");
 288   headers_->AppendHeader("key3", "value3");
 289   headers_->AppendHeader("KEY1", "value1.2");
 290
 291   BalsaHeaders::const_header_lines_key_iterator i =
 292       headers_->GetIteratorForKey("key1");
 293
 294   ASSERT_EQ(headers_->header_lines_key_end(),
 295             headers_->GetIteratorForKey("foobar"));
 296   ASSERT_NE(headers_->header_lines_key_end(), i);
 297   ASSERT_EQ("key1", i->first);
 298   ASSERT_EQ("value1", i->second);
 299   ++i;
 300   ASSERT_EQ("key1", i->first);
 301   ASSERT_EQ("value1.1", i->second);
 302   ++i;
 303   ASSERT_EQ("KEY1", i->first);
 304   ASSERT_EQ("value1.2", i->second);
 305   ++i;
 306   ASSERT_EQ(headers_->header_lines_key_end(), i);
 307 }
 308
 309 TEST_F(BalsaHeadersTest, RemoveAllOfHeader) {
 310   headers_->AppendHeader("key1", "value1");
 311   headers_->AppendHeader("key2", "value2");
 312   headers_->AppendHeader("key1", "value1.1");
 313   headers_->AppendHeader("key3", "value3");
 314   headers_->AppendHeader("key1", "value1.2");
 315   headers_->AppendHeader("kEY1", "value1.3");
 316
 317   ASSERT_EQ(6, std::distance(headers_->header_lines_begin(),
 318                              headers_->header_lines_end()));
 319   headers_->RemoveAllOfHeader("key1");
 320   ASSERT_EQ(2, std::distance(headers_->header_lines_begin(),
 321                              headers_->header_lines_end()));
 322 }
 323
 324 TEST_F(BalsaHeadersTest, RemoveAllHeadersWithPrefix) {
 325   headers_->AppendHeader("1key", "value1");
 326   headers_->AppendHeader("2key", "value2");
 327   headers_->AppendHeader("1kEz", "value1.1");
 328   headers_->AppendHeader("key3", "value3");
 329   headers_->AppendHeader("1KEEjkladf", "value1.2");
 330
 331   ASSERT_EQ(5, std::distance(headers_->header_lines_begin(),
 332                              headers_->header_lines_end()));
 333   headers_->RemoveAllHeadersWithPrefix("1ke");
 334   ASSERT_EQ(2, std::distance(headers_->header_lines_begin(),
 335                              headers_->header_lines_end()));
 336 }
 337
 338 TEST_F(BalsaHeadersTest, WriteRequestHeaderAndEndingToBuffer) {
 339   headers_->AppendHeader("key1", "value1");
 340   headers_->AppendHeader("key2", "value2");
 341   headers_->AppendHeader("key1", "value1.1");
 342
 343   headers_->SetRequestFirstlineFromStringPieces("GET", "/", "HTTP/1.0");
 344
 345   std::string expected = "GET / HTTP/1.0\r\n"
 346       "key1: value1\r\n"
 347       "key2: value2\r\n"
 348       "key1: value1.1\r\n\r\n";
 349   StringBuffer buffer;
 350   headers_->WriteHeaderAndEndingToBuffer(&buffer);
 351   ASSERT_EQ(expected, buffer.string());
 352 }
 353
 354 TEST_F(BalsaHeadersTest, WriteResponseHeaderAndEndingToBuffer) {
 355   headers_->AppendHeader("key1", "value1");
 356   headers_->AppendHeader("key2", "value2");
 357   headers_->AppendHeader("key1", "value1.1");
 358
 359   headers_->SetResponseFirstlineFromStringPieces("HTTP/1.0", "200", "OK");
 360
 361   std::string expected = "HTTP/1.0 200 OK\r\n"
 362       "key1: value1\r\n"
 363       "key2: value2\r\n"
 364       "key1: value1.1\r\n\r\n";
 365   StringBuffer buffer;
 366   headers_->WriteHeaderAndEndingToBuffer(&buffer);
 367   ASSERT_EQ(expected, buffer.string());
 368 }
 369
 370 TEST_F(BalsaHeadersTest, RequestFirstLine) {
 371   headers_->SetRequestFirstlineFromStringPieces("HEAD", "/path", "HTTP/1.1");
 372
 373   ASSERT_EQ("HEAD /path HTTP/1.1", headers_->first_line());
 374   ASSERT_EQ("HEAD", headers_->request_method());
 375   ASSERT_EQ("/path", headers_->request_uri());
 376   ASSERT_EQ("HTTP/1.1", headers_->request_version());
 377 }
 378
 379 TEST_F(BalsaHeadersTest, ResponseFirstLine) {
 380   headers_->SetRequestFirstlineFromStringPieces("HTTP/1.0", "403", "FORBIDDEN");
 381
 382   ASSERT_EQ("HTTP/1.0 403 FORBIDDEN", headers_->first_line());
 383   ASSERT_EQ("HTTP/1.0", headers_->response_version());
 384   ASSERT_EQ("403", headers_->response_code());
 385   ASSERT_EQ("FORBIDDEN", headers_->response_reason_phrase());
 386 }
 387
 388 }  // namespace
 389
 390 }  // namespace net