src/net/instaweb/rewriter/meta_tag_filter_test.cc - incubator-pagespeed-debian - Git at Google

 /*
  * Copyright 2011 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 // Author: nforman@google.com (Naomi Forman)
 //
 // This file contains unit tests for the MetaTagFilter.

 #include "net/instaweb/rewriter/public/meta_tag_filter.h"

 #include "net/instaweb/rewriter/public/rewrite_driver.h"
 #include "net/instaweb/rewriter/public/rewrite_options.h"
 #include "net/instaweb/rewriter/public/rewrite_test_base.h"
 #include "pagespeed/kernel/base/gtest.h"
 #include "pagespeed/kernel/base/string.h"
 #include "pagespeed/kernel/base/string_util.h"
 #include "pagespeed/kernel/http/content_type.h"
 #include "pagespeed/kernel/http/http_names.h"  // for HttpAttributes, etc
 #include "pagespeed/kernel/http/response_headers.h"

 namespace net_instaweb {

 namespace {
 // Test fixture for MetaTagFilter unit tests.
 class MetaTagFilterTest : public RewriteTestBase {
  protected:
   virtual void SetUp() {
     options()->EnableFilter(RewriteOptions::kConvertMetaTags);
     RewriteTestBase::SetUp();
     rewrite_driver()->AddFilters();
     headers_.Clear();
     rewrite_driver()->set_response_headers_ptr(&headers_);
     headers_.Replace(HttpAttributes::kContentType, "text/html");
   }

   ResponseHeaders* headers() {
     return &headers_;
   }
  private:
   ResponseHeaders headers_;
 };

 const char kMetaTagDoc[] =
     "<html><head>"
     "<meta http-equiv=\"Content-Type\" content=\"text/html;  charset=UTF-8\">"
     "<META HTTP-EQUIV=\"CONTENT-LANGUAGE\" CONTENT=\"en-US,fr\">"
     "</head><body></body></html>";

 TEST_F(MetaTagFilterTest, TestTags) {
   ValidateNoChanges("convert_tags", kMetaTagDoc);
   ConstStringStarVector values;
   EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(1, values.size());
   EXPECT_TRUE(StringCaseEqual(*values[0], "text/html; charset=UTF-8"))
       << *values[0];
 }

 const char kMetaTagDocInvalidAttribute[] =
     "<html><head>"
     "<meta http-equiv=\"Content-Type\" content=\"text/html;"
     "      charset=U\r\nTF-8\">"
     "</head><body></body></html>";

 TEST_F(MetaTagFilterTest, TestRejectInvalidAttribute) {
   headers()->RemoveAll(HttpAttributes::kContentType);
   ValidateNoChanges("convert_tags_invalid_attribute",
                     kMetaTagDocInvalidAttribute);
   ConstStringStarVector values;
   EXPECT_FALSE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(0, values.size());
 }

 const char kMetaTagDoubleDoc[] =
     "<html><head>"
     "<meta http-equiv=\"Content-Type\" content=\"text/html;  charset=UTF-8\">"
     "<meta http-equiv=\"Content-Type\" content=\"text/html;  charset=UTF-8\">"
     "<META HTTP-EQUIV=\"CONTENT-LANGUAGE\" CONTENT=\"en-US,FR\">"
     "<META HTTP-EQUIV=\"CONTENT-LANGUAGE\" CONTENT=\"en-US,fr\">"
     "</head><body></body></html>";

 TEST_F(MetaTagFilterTest, TestDoubleTags) {
   ValidateNoChanges("convert_tags_once", kMetaTagDoubleDoc);
   ConstStringStarVector values;
   EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(1, values.size());
   EXPECT_TRUE(StringCaseEqual(*values[0], "text/html; charset=UTF-8"))
       << *values[0];
 }

 TEST_F(MetaTagFilterTest, TestEquivNoValue) {
   // Make sure we don't crash when a meta http-equiv has no content given.
   ValidateNoChanges("no_value", "<meta http-equiv='NoValue'>");
 }

 const char kMetaTagConflictDoc[] =
     "<html><head>"
     "<meta http-equiv=\"Content-Type\" content=\"text/html;  charset=UTF-8\">"
     "<meta http-equiv=\"Content-Type\" content=\"text/xml;  charset=UTF-16\">"
     "<meta http-equiv=\"Content-Type\" content=\"text/xml\">"
     "</head><body></body></html>";


 TEST_F(MetaTagFilterTest, TestConflictingTags) {
   ValidateNoChanges("convert_tags_first", kMetaTagConflictDoc);
   ConstStringStarVector values;
   EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(1, values.size());
   EXPECT_TRUE(StringCaseEqual(*values[0], "text/html; charset=UTF-8"))
       << *values[0];
 }

 const char kMetaTagCharset[] =
     "<html><head>"
     "<meta http-equiv=\"Content-Type\" content=\"text/html\">"
     "<meta charset=\"UTF-8\">"
     "<meta http-equiv=\"Content-Type\" content=\"text/xml; charset=UTF-16\">"
     "</head><body></body></html>";


 TEST_F(MetaTagFilterTest, TestCharset) {
   ValidateNoChanges("convert_charset", kMetaTagCharset);
   ConstStringStarVector values;
   EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(1, values.size());
   const GoogleString* val = values[0];
   EXPECT_TRUE(StringCaseEqual(*val, "text/html; charset=UTF-8")) << *val;
 }

 const char kMetaTagCharsetOnly[] =
     "<html><head>"
     "<meta charset=\"UTF-8\">"
     "</head><body></body></html>";

 TEST_F(MetaTagFilterTest, TestCharsetOnly) {
   // Merges charset into pre-existing mimetype.
   ValidateNoChanges("convert_charset_only", kMetaTagCharsetOnly);
   ConstStringStarVector values;
   EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(1, values.size());
   const GoogleString* val = values[0];
   EXPECT_TRUE(StringCaseEqual(*val, "text/html; charset=UTF-8")) << *val;
 }

 TEST_F(MetaTagFilterTest, TestCharsetNoUpstream) {
   // No mimetype to merge charset into, it gets dropped.
   headers()->RemoveAll(HttpAttributes::kContentType);
   ValidateNoChanges("convert_charset_only", kMetaTagCharsetOnly);
   ConstStringStarVector values;
   EXPECT_FALSE(headers()->Lookup(HttpAttributes::kContentType, &values));
 }

 const char kMetaTagDoNothing[] =
     "<html><head>"
     "<meta http-equiv=\"\" content=\"\">"
     "<meta http-equiv=\"  \" content=\"\">"
     "<meta http-equiv=\"  :\" content=\"\">"
     "<meta http-equiv=\"Content-Length\" content=\"123\">"
     "</head><body></body></html>";


 TEST_F(MetaTagFilterTest, TestDoNothing) {
   ValidateNoChanges("do_nothing", kMetaTagDoNothing);
   ASSERT_EQ(1, headers()->NumAttributes());
   EXPECT_STREQ("text/html", headers()->Lookup1(HttpAttributes::kContentType));
 }

 const char kMetaTagNoScriptDoc[] =
     "<html><head>"
     "<noscript>"
     "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">"
     "</noscript>"
     "</head><body></body></html>";

 TEST_F(MetaTagFilterTest, TestNoScript) {
   ValidateNoChanges("no_script", kMetaTagDoNothing);
   ASSERT_EQ(1, headers()->NumAttributes());
   EXPECT_STREQ("text/html", headers()->Lookup1(HttpAttributes::kContentType));
 }

 const char kMetaTagNoQuotes[] =
     "<html><head>"
     "<meta http-equiv=Content-Type content=text/html; charset=UTF-8>"
     "</head><body></body></html>";

 TEST_F(MetaTagFilterTest, TestNoQuotes) {
   // See http://webdesign.about.com/od/metatags/qt/meta-charset.htm for an
   // explanation of why we are testing this invalid format.
   ValidateNoChanges("convert_tags", kMetaTagNoQuotes);
   ConstStringStarVector values;
   EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(1, values.size());
   EXPECT_TRUE(StringCaseEqual(*values[0], "text/html; charset=UTF-8"))
       << *values[0];
 }

 TEST_F(MetaTagFilterTest, DoNotOverrideWithFakeXhtmlUnsure) {
   // We shouldn't override with XHTML even if mimetype is unknown.
   // This uses a bogus "XHTML" mimetype which we recognized for some versions.
   headers()->RemoveAll(HttpAttributes::kContentType);
   ValidateNoChanges("no_override", "<meta http-equiv=\"Content-Type\" "
                                    "content=\"text/xhtml; charset=UTF-8\">");
   ConstStringStarVector values;
   EXPECT_FALSE(headers()->Lookup(HttpAttributes::kContentType, &values));
 }

 TEST_F(MetaTagFilterTest, DoNotOverrideWithRealXhtmlUnsure) {
   // We shouldn't override with XHTML even if mimetype is unknown.
   headers()->RemoveAll(HttpAttributes::kContentType);
   ValidateNoChanges("no_override",
                     StrCat("<meta http-equiv=\"Content-Type\" content=\"",
                            kContentTypeXhtml.mime_type(),
                            " ;charset=UTF-8\">"));
   ConstStringStarVector values;
   EXPECT_FALSE(headers()->Lookup(HttpAttributes::kContentType, &values));
 }

 TEST_F(MetaTagFilterTest, DoNotOverrideWithFakeXhtmlKnown) {
   // We shouldn't override with XHTML if the server already knows it's HTML
   // This uses a bogus "XHTML" mimetype which we recognized for some versions.
   ValidateNoChanges("no_override", "<meta http-equiv=\"Content-Type\" "
                                    "content=\"text/xhtml; charset=UTF-8\">");
   ConstStringStarVector values;
   EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(1, values.size());
   EXPECT_TRUE(StringCaseEqual(*values[0], "text/html")) << *values[0];
 }

 TEST_F(MetaTagFilterTest, DoNotOverrideWithRealXhtmlKnown) {
   // We shouldn't override with XHTML if the server already knows it's HTML
   ValidateNoChanges("no_override",
                     StrCat("<meta http-equiv=\"Content-Type\" content=\"",
                            kContentTypeXhtml.mime_type(), ";charset=UTF-8\">"));
   ConstStringStarVector values;
   EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(1, values.size());
   EXPECT_TRUE(StringCaseEqual(*values[0], "text/html")) << *values[0];
 }

 TEST_F(MetaTagFilterTest, DoNotOverrideCharsetBothXhtml) {
   // An XHTML document specifying a non-utf8 encoding via a http-equiv meta
   // should not take effect, either.
   GoogleString initial_header = StrCat(kContentTypeXhtml.mime_type(),
                                        "; charset=UTF-8");
   headers()->Replace(HttpAttributes::kContentType, initial_header);

   ValidateNoChanges("no_override",
                     StrCat("<meta http-equiv=\"Content-Type\" content=\"",
                            kContentTypeXhtml.mime_type(),
                            "; charset=KOI8-R\">"));
   ConstStringStarVector values;
   EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
   ASSERT_EQ(1, values.size());
   EXPECT_EQ(initial_header, *values[0]);
 }

 }  // namespace

 }  // namespace net_instaweb
	/*
	* Copyright 2011 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	// Author: nforman@google.com (Naomi Forman)
	//
	// This file contains unit tests for the MetaTagFilter.

	#include "net/instaweb/rewriter/public/meta_tag_filter.h"

	#include "net/instaweb/rewriter/public/rewrite_driver.h"
	#include "net/instaweb/rewriter/public/rewrite_options.h"
	#include "net/instaweb/rewriter/public/rewrite_test_base.h"
	#include "pagespeed/kernel/base/gtest.h"
	#include "pagespeed/kernel/base/string.h"
	#include "pagespeed/kernel/base/string_util.h"
	#include "pagespeed/kernel/http/content_type.h"
	#include "pagespeed/kernel/http/http_names.h" // for HttpAttributes, etc
	#include "pagespeed/kernel/http/response_headers.h"

	namespace net_instaweb {

	namespace {
	// Test fixture for MetaTagFilter unit tests.
	class MetaTagFilterTest : public RewriteTestBase {
	protected:
	virtual void SetUp() {
	options()->EnableFilter(RewriteOptions::kConvertMetaTags);
	RewriteTestBase::SetUp();
	rewrite_driver()->AddFilters();
	headers_.Clear();
	rewrite_driver()->set_response_headers_ptr(&headers_);
	headers_.Replace(HttpAttributes::kContentType, "text/html");
	}

	ResponseHeaders* headers() {
	return &headers_;
	}
	private:
	ResponseHeaders headers_;
	};

	const char kMetaTagDoc[] =
	"<html><head>"
	"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">"
	"<META HTTP-EQUIV=\"CONTENT-LANGUAGE\" CONTENT=\"en-US,fr\">"
	"</head><body></body></html>";

	TEST_F(MetaTagFilterTest, TestTags) {
	ValidateNoChanges("convert_tags", kMetaTagDoc);
	ConstStringStarVector values;
	EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(1, values.size());
	EXPECT_TRUE(StringCaseEqual(*values[0], "text/html; charset=UTF-8"))
	<< *values[0];
	}

	const char kMetaTagDocInvalidAttribute[] =
	"<html><head>"
	"<meta http-equiv=\"Content-Type\" content=\"text/html;"
	" charset=U\r\nTF-8\">"
	"</head><body></body></html>";

	TEST_F(MetaTagFilterTest, TestRejectInvalidAttribute) {
	headers()->RemoveAll(HttpAttributes::kContentType);
	ValidateNoChanges("convert_tags_invalid_attribute",
	kMetaTagDocInvalidAttribute);
	ConstStringStarVector values;
	EXPECT_FALSE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(0, values.size());
	}

	const char kMetaTagDoubleDoc[] =
	"<html><head>"
	"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">"
	"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">"
	"<META HTTP-EQUIV=\"CONTENT-LANGUAGE\" CONTENT=\"en-US,FR\">"
	"<META HTTP-EQUIV=\"CONTENT-LANGUAGE\" CONTENT=\"en-US,fr\">"
	"</head><body></body></html>";

	TEST_F(MetaTagFilterTest, TestDoubleTags) {
	ValidateNoChanges("convert_tags_once", kMetaTagDoubleDoc);
	ConstStringStarVector values;
	EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(1, values.size());
	EXPECT_TRUE(StringCaseEqual(*values[0], "text/html; charset=UTF-8"))
	<< *values[0];
	}

	TEST_F(MetaTagFilterTest, TestEquivNoValue) {
	// Make sure we don't crash when a meta http-equiv has no content given.
	ValidateNoChanges("no_value", "<meta http-equiv='NoValue'>");
	}

	const char kMetaTagConflictDoc[] =
	"<html><head>"
	"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">"
	"<meta http-equiv=\"Content-Type\" content=\"text/xml; charset=UTF-16\">"
	"<meta http-equiv=\"Content-Type\" content=\"text/xml\">"
	"</head><body></body></html>";


	TEST_F(MetaTagFilterTest, TestConflictingTags) {
	ValidateNoChanges("convert_tags_first", kMetaTagConflictDoc);
	ConstStringStarVector values;
	EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(1, values.size());
	EXPECT_TRUE(StringCaseEqual(*values[0], "text/html; charset=UTF-8"))
	<< *values[0];
	}

	const char kMetaTagCharset[] =
	"<html><head>"
	"<meta http-equiv=\"Content-Type\" content=\"text/html\">"
	"<meta charset=\"UTF-8\">"
	"<meta http-equiv=\"Content-Type\" content=\"text/xml; charset=UTF-16\">"
	"</head><body></body></html>";


	TEST_F(MetaTagFilterTest, TestCharset) {
	ValidateNoChanges("convert_charset", kMetaTagCharset);
	ConstStringStarVector values;
	EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(1, values.size());
	const GoogleString* val = values[0];
	EXPECT_TRUE(StringCaseEqual(val, "text/html; charset=UTF-8")) << val;
	}

	const char kMetaTagCharsetOnly[] =
	"<html><head>"
	"<meta charset=\"UTF-8\">"
	"</head><body></body></html>";

	TEST_F(MetaTagFilterTest, TestCharsetOnly) {
	// Merges charset into pre-existing mimetype.
	ValidateNoChanges("convert_charset_only", kMetaTagCharsetOnly);
	ConstStringStarVector values;
	EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(1, values.size());
	const GoogleString* val = values[0];
	EXPECT_TRUE(StringCaseEqual(val, "text/html; charset=UTF-8")) << val;
	}

	TEST_F(MetaTagFilterTest, TestCharsetNoUpstream) {
	// No mimetype to merge charset into, it gets dropped.
	headers()->RemoveAll(HttpAttributes::kContentType);
	ValidateNoChanges("convert_charset_only", kMetaTagCharsetOnly);
	ConstStringStarVector values;
	EXPECT_FALSE(headers()->Lookup(HttpAttributes::kContentType, &values));
	}

	const char kMetaTagDoNothing[] =
	"<html><head>"
	"<meta http-equiv=\"\" content=\"\">"
	"<meta http-equiv=\" \" content=\"\">"
	"<meta http-equiv=\" :\" content=\"\">"
	"<meta http-equiv=\"Content-Length\" content=\"123\">"
	"</head><body></body></html>";


	TEST_F(MetaTagFilterTest, TestDoNothing) {
	ValidateNoChanges("do_nothing", kMetaTagDoNothing);
	ASSERT_EQ(1, headers()->NumAttributes());
	EXPECT_STREQ("text/html", headers()->Lookup1(HttpAttributes::kContentType));
	}

	const char kMetaTagNoScriptDoc[] =
	"<html><head>"
	"<noscript>"
	"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">"
	"</noscript>"
	"</head><body></body></html>";

	TEST_F(MetaTagFilterTest, TestNoScript) {
	ValidateNoChanges("no_script", kMetaTagDoNothing);
	ASSERT_EQ(1, headers()->NumAttributes());
	EXPECT_STREQ("text/html", headers()->Lookup1(HttpAttributes::kContentType));
	}

	const char kMetaTagNoQuotes[] =
	"<html><head>"
	"<meta http-equiv=Content-Type content=text/html; charset=UTF-8>"
	"</head><body></body></html>";

	TEST_F(MetaTagFilterTest, TestNoQuotes) {
	// See http://webdesign.about.com/od/metatags/qt/meta-charset.htm for an
	// explanation of why we are testing this invalid format.
	ValidateNoChanges("convert_tags", kMetaTagNoQuotes);
	ConstStringStarVector values;
	EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(1, values.size());
	EXPECT_TRUE(StringCaseEqual(*values[0], "text/html; charset=UTF-8"))
	<< *values[0];
	}

	TEST_F(MetaTagFilterTest, DoNotOverrideWithFakeXhtmlUnsure) {
	// We shouldn't override with XHTML even if mimetype is unknown.
	// This uses a bogus "XHTML" mimetype which we recognized for some versions.
	headers()->RemoveAll(HttpAttributes::kContentType);
	ValidateNoChanges("no_override", "<meta http-equiv=\"Content-Type\" "
	"content=\"text/xhtml; charset=UTF-8\">");
	ConstStringStarVector values;
	EXPECT_FALSE(headers()->Lookup(HttpAttributes::kContentType, &values));
	}

	TEST_F(MetaTagFilterTest, DoNotOverrideWithRealXhtmlUnsure) {
	// We shouldn't override with XHTML even if mimetype is unknown.
	headers()->RemoveAll(HttpAttributes::kContentType);
	ValidateNoChanges("no_override",
	StrCat("<meta http-equiv=\"Content-Type\" content=\"",
	kContentTypeXhtml.mime_type(),
	" ;charset=UTF-8\">"));
	ConstStringStarVector values;
	EXPECT_FALSE(headers()->Lookup(HttpAttributes::kContentType, &values));
	}

	TEST_F(MetaTagFilterTest, DoNotOverrideWithFakeXhtmlKnown) {
	// We shouldn't override with XHTML if the server already knows it's HTML
	// This uses a bogus "XHTML" mimetype which we recognized for some versions.
	ValidateNoChanges("no_override", "<meta http-equiv=\"Content-Type\" "
	"content=\"text/xhtml; charset=UTF-8\">");
	ConstStringStarVector values;
	EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(1, values.size());
	EXPECT_TRUE(StringCaseEqual(values[0], "text/html")) << values[0];
	}

	TEST_F(MetaTagFilterTest, DoNotOverrideWithRealXhtmlKnown) {
	// We shouldn't override with XHTML if the server already knows it's HTML
	ValidateNoChanges("no_override",
	StrCat("<meta http-equiv=\"Content-Type\" content=\"",
	kContentTypeXhtml.mime_type(), ";charset=UTF-8\">"));
	ConstStringStarVector values;
	EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(1, values.size());
	EXPECT_TRUE(StringCaseEqual(values[0], "text/html")) << values[0];
	}

	TEST_F(MetaTagFilterTest, DoNotOverrideCharsetBothXhtml) {
	// An XHTML document specifying a non-utf8 encoding via a http-equiv meta
	// should not take effect, either.
	GoogleString initial_header = StrCat(kContentTypeXhtml.mime_type(),
	"; charset=UTF-8");
	headers()->Replace(HttpAttributes::kContentType, initial_header);

	ValidateNoChanges("no_override",
	StrCat("<meta http-equiv=\"Content-Type\" content=\"",
	kContentTypeXhtml.mime_type(),
	"; charset=KOI8-R\">"));
	ConstStringStarVector values;
	EXPECT_TRUE(headers()->Lookup(HttpAttributes::kContentType, &values));
	ASSERT_EQ(1, values.size());
	EXPECT_EQ(initial_header, *values[0]);
	}

	} // namespace

	} // namespace net_instaweb