src/third_party/WebKit/Source/platform/network/HTTPParsersTest.cpp

   1 // Copyright 2014 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 "config.h"
   6 #include "HTTPParsers.h"
   7
   8 #include "wtf/MathExtras.h"
   9 #include "wtf/testing/WTFTestHelpers.h"
  10 #include "wtf/text/AtomicString.h"
  11
  12 #include <gtest/gtest.h>
  13
  14 namespace blink {
  15
  16 namespace {
  17
  18 size_t parseHTTPHeader(const char* data, String& failureReason, AtomicString& nameStr, AtomicString& valueStr)
  19 {
  20     return blink::parseHTTPHeader(data, strlen(data), failureReason, nameStr, valueStr);
  21 }
  22
  23 } // namespace
  24
  25 TEST(HTTPParsersTest, ParseCacheControl)
  26 {
  27     CacheControlHeader header;
  28
  29     header = parseCacheControlDirectives("no-cache", AtomicString());
  30     EXPECT_TRUE(header.parsed);
  31     EXPECT_TRUE(header.containsNoCache);
  32     EXPECT_FALSE(header.containsNoStore);
  33     EXPECT_FALSE(header.containsMustRevalidate);
  34     EXPECT_TRUE(std::isnan(header.maxAge));
  35
  36     header = parseCacheControlDirectives("no-cache no-store", AtomicString());
  37     EXPECT_TRUE(header.parsed);
  38     EXPECT_TRUE(header.containsNoCache);
  39     EXPECT_FALSE(header.containsNoStore);
  40     EXPECT_FALSE(header.containsMustRevalidate);
  41     EXPECT_TRUE(std::isnan(header.maxAge));
  42
  43     header = parseCacheControlDirectives("no-store must-revalidate", AtomicString());
  44     EXPECT_TRUE(header.parsed);
  45     EXPECT_FALSE(header.containsNoCache);
  46     EXPECT_TRUE(header.containsNoStore);
  47     EXPECT_FALSE(header.containsMustRevalidate);
  48     EXPECT_TRUE(std::isnan(header.maxAge));
  49
  50     header = parseCacheControlDirectives("max-age=0", AtomicString());
  51     EXPECT_TRUE(header.parsed);
  52     EXPECT_FALSE(header.containsNoCache);
  53     EXPECT_FALSE(header.containsNoStore);
  54     EXPECT_FALSE(header.containsMustRevalidate);
  55     EXPECT_EQ(0.0, header.maxAge);
  56
  57     header = parseCacheControlDirectives("max-age", AtomicString());
  58     EXPECT_TRUE(header.parsed);
  59     EXPECT_FALSE(header.containsNoCache);
  60     EXPECT_FALSE(header.containsNoStore);
  61     EXPECT_FALSE(header.containsMustRevalidate);
  62     EXPECT_TRUE(std::isnan(header.maxAge));
  63
  64     header = parseCacheControlDirectives("max-age=0 no-cache", AtomicString());
  65     EXPECT_TRUE(header.parsed);
  66     EXPECT_FALSE(header.containsNoCache);
  67     EXPECT_FALSE(header.containsNoStore);
  68     EXPECT_FALSE(header.containsMustRevalidate);
  69     EXPECT_EQ(0.0, header.maxAge);
  70
  71     header = parseCacheControlDirectives("no-cache=foo", AtomicString());
  72     EXPECT_TRUE(header.parsed);
  73     EXPECT_FALSE(header.containsNoCache);
  74     EXPECT_FALSE(header.containsNoStore);
  75     EXPECT_FALSE(header.containsMustRevalidate);
  76     EXPECT_TRUE(std::isnan(header.maxAge));
  77
  78     header = parseCacheControlDirectives("nonsense", AtomicString());
  79     EXPECT_TRUE(header.parsed);
  80     EXPECT_FALSE(header.containsNoCache);
  81     EXPECT_FALSE(header.containsNoStore);
  82     EXPECT_FALSE(header.containsMustRevalidate);
  83     EXPECT_TRUE(std::isnan(header.maxAge));
  84
  85     header = parseCacheControlDirectives("\rno-cache\n\t\v\0\b", AtomicString());
  86     EXPECT_TRUE(header.parsed);
  87     EXPECT_TRUE(header.containsNoCache);
  88     EXPECT_FALSE(header.containsNoStore);
  89     EXPECT_FALSE(header.containsMustRevalidate);
  90     EXPECT_TRUE(std::isnan(header.maxAge));
  91
  92     header = parseCacheControlDirectives("      no-cache       ", AtomicString());
  93     EXPECT_TRUE(header.parsed);
  94     EXPECT_TRUE(header.containsNoCache);
  95     EXPECT_FALSE(header.containsNoStore);
  96     EXPECT_FALSE(header.containsMustRevalidate);
  97     EXPECT_TRUE(std::isnan(header.maxAge));
  98
  99     header = parseCacheControlDirectives(AtomicString(), "no-cache");
 100     EXPECT_TRUE(header.parsed);
 101     EXPECT_TRUE(header.containsNoCache);
 102     EXPECT_FALSE(header.containsNoStore);
 103     EXPECT_FALSE(header.containsMustRevalidate);
 104     EXPECT_TRUE(std::isnan(header.maxAge));
 105 }
 106
 107 TEST(HTTPParsersTest, parseHTTPHeaderSimple)
 108 {
 109     String failureReason;
 110     AtomicString name, value;
 111     EXPECT_EQ(12u, parseHTTPHeader("foo:   bar\r\notherdata", failureReason, name, value));
 112     EXPECT_TRUE(failureReason.isEmpty());
 113     EXPECT_EQ("foo", name.string());
 114     EXPECT_EQ("bar", value.string());
 115 }
 116
 117 TEST(HTTPParsersTest, parseHTTPHeaderEmptyName)
 118 {
 119     String failureReason;
 120     AtomicString name, value;
 121     EXPECT_EQ(0u, parseHTTPHeader(": bar\r\notherdata", failureReason, name, value));
 122     EXPECT_EQ("Header name is missing", failureReason);
 123 }
 124
 125 TEST(HTTPParsersTest, parseHTTPHeaderEmptyValue)
 126 {
 127     String failureReason;
 128     AtomicString name, value;
 129     EXPECT_EQ(7u, parseHTTPHeader("foo: \r\notherdata", failureReason, name, value));
 130     EXPECT_TRUE(failureReason.isEmpty());
 131     EXPECT_EQ("foo", name.string());
 132     EXPECT_TRUE(value.isEmpty());
 133 }
 134
 135 TEST(HTTPParsersTest, parseHTTPHeaderInvalidName)
 136 {
 137     String failureReason;
 138     AtomicString name, value;
 139     EXPECT_EQ(0u, parseHTTPHeader("\xfa: \r\notherdata", failureReason, name, value));
 140     EXPECT_EQ("Invalid UTF-8 sequence in header name", failureReason);
 141 }
 142
 143 TEST(HTTPParsersTest, parseHTTPHeaderInvalidValue)
 144 {
 145     String failureReason;
 146     AtomicString name, value;
 147     EXPECT_EQ(0u, parseHTTPHeader("foo: \xfa\r\notherdata", failureReason, name, value));
 148     EXPECT_EQ("Invalid UTF-8 sequence in header value", failureReason);
 149 }
 150
 151 TEST(HTTPParsersTest, parseHTTPHeaderEmpty)
 152 {
 153     String failureReason;
 154     AtomicString name, value;
 155     EXPECT_EQ(0u, parseHTTPHeader("", failureReason, name, value));
 156     EXPECT_EQ("Unterminated header name", failureReason);
 157 }
 158
 159 TEST(HTTPParsersTest, parseHTTPHeaderEmptyLine)
 160 {
 161     String failureReason;
 162     AtomicString name, value;
 163     EXPECT_EQ(2u, parseHTTPHeader("\r\notherdata", failureReason, name, value));
 164     EXPECT_TRUE(failureReason.isEmpty());
 165     EXPECT_TRUE(name.isNull());
 166     EXPECT_TRUE(value.isNull());
 167 }
 168
 169 TEST(HTTPParsersTest, parseHTTPHeaderUnexpectedCRinName)
 170 {
 171     String failureReason;
 172     AtomicString name, value;
 173     EXPECT_EQ(0u, parseHTTPHeader("foo\rotherdata\n", failureReason, name, value));
 174     EXPECT_EQ("Unexpected CR in name at foo", failureReason);
 175 }
 176
 177 TEST(HTTPParsersTest, parseHTTPHeaderUnexpectedLFinName)
 178 {
 179     String failureReason;
 180     AtomicString name, value;
 181     EXPECT_EQ(0u, parseHTTPHeader("foo\notherdata\n", failureReason, name, value));
 182     EXPECT_EQ("Unexpected LF in name at foo", failureReason);
 183 }
 184
 185 TEST(HTTPParsersTest, parseHTTPHeaderUnexpectedLFinValue)
 186 {
 187     String failureReason;
 188     AtomicString name, value;
 189     EXPECT_EQ(0u, parseHTTPHeader("foo: bar\notherdata\n", failureReason, name, value));
 190     EXPECT_EQ("Unexpected LF in value at bar", failureReason);
 191 }
 192
 193 TEST(HTTPParsersTest, parseHTTPHeaderNoLFAtEndOfLine)
 194 {
 195     String failureReason;
 196     AtomicString name, value;
 197     EXPECT_EQ(0u, parseHTTPHeader("foo: bar\r", failureReason, name, value));
 198     EXPECT_EQ("LF doesn't follow CR after value at ", failureReason);
 199 }
 200
 201 TEST(HTTPParsersTest, parseHTTPHeaderNoLF)
 202 {
 203     String failureReason;
 204     AtomicString name, value;
 205     EXPECT_EQ(0u, parseHTTPHeader("foo: bar\rhoge\r\n", failureReason, name, value));
 206     EXPECT_EQ("LF doesn't follow CR after value at hoge\r\n", failureReason);
 207 }
 208
 209 TEST(HTTPParsersTest, parseHTTPHeaderTwoLines)
 210 {
 211     const char data[] = "foo: bar\r\nhoge: fuga\r\nxxx";
 212     String failureReason;
 213     AtomicString name, value;
 214
 215     EXPECT_EQ(10u, parseHTTPHeader(data, failureReason, name, value));
 216     EXPECT_TRUE(failureReason.isEmpty());
 217     EXPECT_EQ("foo", name.string());
 218     EXPECT_EQ("bar", value.string());
 219
 220     EXPECT_EQ(12u, parseHTTPHeader(data + 10, failureReason, name, value));
 221     EXPECT_TRUE(failureReason.isEmpty());
 222     EXPECT_EQ("hoge", name.string());
 223     EXPECT_EQ("fuga", value.string());
 224 }
 225
 226 } // namespace blink
 227