net/base/url_search_params_view_unittest.cc - chromium/src - Git at Google

 // Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "net/base/url_search_params_view.h"

 #include <string>
 #include <vector>

 #include "base/containers/flat_map.h"
 #include "base/strings/strcat.h"
 #include "base/strings/string_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"

 namespace net {
 namespace {

 using ::testing::ElementsAre;
 using ::testing::Pair;

 TEST(UrlSearchParamsViewTest, ParseAllSearchParams) {
   const GURL url("https://a.test/index.html?a=1&b=2&c=3");
   const UrlSearchParamsView search_params(url);
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("a", "1"), Pair("b", "2"), Pair("c", "3")));
 }

 TEST(UrlSearchParamsViewTest, ParseSearchParamUnescapeValue) {
   const GURL url(R"(https://a.test/index.html?a=a%20b%20c)");
   const UrlSearchParamsView search_params(url);
   EXPECT_EQ(search_params.GetDecodedParamsForTesting().size(), 1u);
   EXPECT_EQ(search_params.GetDecodedParamsForTesting()[0].second, "a b c");
 }

 TEST(UrlSearchParamsViewTest, DeleteOneSearchParams) {
   const GURL url("https://a.test/index.html?a=1&b=2&c=3");
   UrlSearchParamsView search_params(url);
   search_params.DeleteAllWithNames({"b"});
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("a", "1"), Pair("c", "3")));
 }

 TEST(UrlSearchParamsViewTest, DeleteAllExceptOneSearchParams) {
   const GURL url("https://a.test/index.html?a=1&b=2&c=3");
   UrlSearchParamsView search_params(url);
   search_params.DeleteAllExceptWithNames({"b"});
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("b", "2")));
 }

 TEST(UrlSearchParamsViewTest, SortSearchParams) {
   const GURL url("https://a.test/index.html?c=3&b=2&a=1&c=2&a=5");
   UrlSearchParamsView search_params(url);
   search_params.Sort();
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("a", "1"), Pair("a", "5"), Pair("b", "2"),
                           Pair("c", "3"), Pair("c", "2")));
 }

 TEST(UrlSearchParamsViewTest, SortSearchParamsPercentEncoded) {
   const GURL url("https://a.test/index.html?c=3&b=2&a=1&%63=2&a=5");
   UrlSearchParamsView search_params(url);
   search_params.Sort();
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("a", "1"), Pair("a", "5"), Pair("b", "2"),
                           Pair("c", "3"), Pair("c", "2")));
 }

 TEST(UrlSearchParamsViewTest, ParseSearchParamsSpacePlusAndPercentEncoded) {
   const GURL url(
       R"(https://a.test/index.html?c+1=3&b+%202=2&a=1&%63%201=2&a=5)");
   const UrlSearchParamsView search_params(url);
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("c 1", "3"), Pair("b  2", "2"), Pair("a", "1"),
                           Pair("c 1", "2"), Pair("a", "5")));
 }

 TEST(UrlSearchParamsViewTest, ParseSearchParamsDoubleCodePoint) {
   const GURL url(R"(https://a.test/index.html?%C3%A9=foo)");
   const UrlSearchParamsView search_params(url);
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("é", "foo")));
 }

 TEST(UrlSearchParamsViewTest, SortSearchParamsDoubleCodePoint) {
   const GURL url(R"(https://a.test/index.html?%C3%A9=f&a=2&c=4&é=b)");
   UrlSearchParamsView search_params(url);
   search_params.Sort();
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("a", "2"), Pair("c", "4"), Pair("é", "f"),
                           Pair("é", "b")));
 }

 TEST(UrlSearchParamsViewTest, ParseSearchParamsTripleCodePoint) {
   const GURL url(R"(https://a.test/index.html?%E3%81%81=foo)");
   const UrlSearchParamsView search_params(url);
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("ぁ", "foo")));
 }

 TEST(UrlSearchParamsViewTest, ParseSearchParamsQuadrupleCodePoint) {
   const GURL url(R"(https://a.test/index.html?%F0%90%A8%80=foo)");
   const UrlSearchParamsView search_params(url);
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("𐨀", "foo")));
 }

 // In case an invalid UTF-8 sequence is entered, it would be replaced with
 // the U+FFFD REPLACEMENT CHARACTER: �.
 TEST(UrlSearchParamsViewTest, ParseSearchParamsInvalidCodePoint) {
   const GURL url(R"(https://a.test/index.html?%C3=foo)");
   const UrlSearchParamsView search_params(url);
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("�", "foo")));
 }

 TEST(UrlSearchParamsViewTest, ParseSearchParamsSpecialCharacters) {
   // Use special characters in both `keys` and `values`.
   const base::flat_map<std::string, std::string> percent_encoding = {
       {"!", "%21"},    {R"(")", "%22"},  // double quote character: "
       {"#", "%23"},    {"$", "%24"},       {"%", "%25"},    {"&", "%26"},
       {"'", "%27"},    {"(", "%28"},       {")", "%29"},    {"*", R"(%2A)"},
       {"+", R"(%2B)"}, {",", R"(%2C)"},    {"-", R"(%2D)"}, {".", R"(%2E)"},
       {"/", R"(%2F)"}, {":", R"(%3A)"},    {";", "%3B"},    {"<", R"(%3C)"},
       {"=", R"(%3D)"}, {">", R"(%3E)"},    {"?", R"(%3F)"}, {"@", "%40"},
       {"[", "%5B"},    {R"(\)", R"(%5C)"}, {"]", R"(%5D)"}, {"^", R"(%5E)"},
       {"_", R"(%5F)"}, {"`", "%60"},       {"{", "%7B"},    {"|", R"(%7C)"},
       {"}", R"(%7D)"}, {"~", R"(%7E)"},    {"", ""},
   };

   for (const auto& [key, value] : percent_encoding) {
     std::string template_url = R"(https://a.test/index.html?$key=$value)";

     base::ReplaceSubstringsAfterOffset(&template_url, 0, "$key", value);
     base::ReplaceSubstringsAfterOffset(&template_url, 0, "$value", value);

     const GURL url(template_url);
     const UrlSearchParamsView search_params = UrlSearchParamsView(url);
     EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
                 ElementsAre(Pair(key, key)));
   }
 }

 TEST(UrlSearchParamsViewTest, ParseSearchParamsEmptyKeyOrValues) {
   const GURL url("https://a.test/index.html?a&b&c&d&=5&=1");
   const UrlSearchParamsView search_params(url);
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("a", ""), Pair("b", ""), Pair("c", ""),
                           Pair("d", ""), Pair("", "5"), Pair("", "1")));
 }

 TEST(UrlSearchParamsViewTest, ParseSearchParamsInvalidEscapeTest) {
   const GURL url(R"(https://a.test/index.html?a=%3&%3=b)");
   const UrlSearchParamsView search_params(url);
   EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
               ElementsAre(Pair("a", "%3"), Pair("%3", "b")));
 }

 struct QueryPair {
   std::string_view query_a;
   std::string_view query_b;
 };

 GURL MakeUrlWithQuery(std::string_view query) {
   // The trailing "#" makes GURL preserve trailing spaces. It doesn't form part
   // of the query and makes no difference in other cases.
   return GURL(base::StrCat({"http://a.test/?", query, "#"}));
 }

 TEST(UrlSearchParamsViewTest, Equals) {
   static constexpr QueryPair kEqualsCases[] = {
       {"a", "a="},
       {"a=+", "a=%20"},
       {"=&", "="},
       {"%61=%62", "a=b"},
       {"%c0=%c1", "%c1=%c0"},
       {"%61=1&a=2", "a=1&%61=2"},
       {"a=5&b=%6", "a=5&b=%6"},
   };

   for (const auto& [query_a, query_b] : kEqualsCases) {
     const GURL url_a = MakeUrlWithQuery(query_a);
     const GURL url_b = MakeUrlWithQuery(query_b);
     const UrlSearchParamsView search_params_a(url_a);
     const UrlSearchParamsView search_params_b(url_b);
     EXPECT_EQ(search_params_a, search_params_b)
         << "a=" << url_a << ", b=" << url_b;
   }
 }

 TEST(UrlSearchParamsViewTest, NotEquals) {
   static constexpr QueryPair kNotEqualsCases[] = {
       {"a=1&a=2", "a=2&a=1"},
       {"a=%c2%a2", "a=%c2%a3"},
       {"a", "b"},
       {"%c2%a2", "%c2%a3"},
       {"=&=", "="},
       {"A=0", "a=0"},
       {"%cO=1", "%co=1"},
       {"%c0=", "=%c0"},
   };

   for (const auto& [query_a, query_b] : kNotEqualsCases) {
     const GURL url_a = MakeUrlWithQuery(query_a);
     const GURL url_b = MakeUrlWithQuery(query_b);
     const UrlSearchParamsView search_params_a(url_a);
     const UrlSearchParamsView search_params_b(url_b);
     EXPECT_NE(search_params_a, search_params_b)
         << "a=" << url_a << ", b=" << url_b;
   }
 }

 TEST(UrlSearchParamsViewTest, SerializeAsUtf8WithNoQuery) {
   const GURL no_query("http://a.test/");
   const UrlSearchParamsView params(no_query);
   EXPECT_EQ(params.SerializeAsUtf8(), "");
 }

 TEST(UrlSearchParamsViewTest, SerializeAsUtf8Cases) {
   static constexpr std::string_view kNulEqualsNul("\0=\0", 3);
   static constexpr QueryPair kQueryAndExpected[] = {
       {"", ""},
       {"a", "a="},
       {"&", "="},
       {"&b", "=&b="},
       {"&&", "=&="},
       {"a==b", "a=%3Db"},
       {"%3d=b", "%3D=b"},
       {"%26&=%26", "%26=&=%26"},   // '&' is escaped in keys and values
       {"+=+", " = "},              // ' ' is not escaped
       {"%20=+%20+", " =   "},      // %20 is ' '
       {"%=%", "%25=%25"},          // Invalid escape is made valid
       {"%23=%23", "%23=%23"},      // '#' is escaped
       {kNulEqualsNul, "%00=%00"},  // '\0' is escaped
       {"%c2%a5", "\xc2\xa5="},     // Valid UTF-8 is not escaped
       {"=%c2%a5", "=\xc2\xa5"},
       {"%c2=%a5", "\xef\xbf\xbd=\xef\xbf\xbd"},  // Invalid UTF-8
   };
   for (const auto& [query, expected] : kQueryAndExpected) {
     SCOPED_TRACE(testing::Message() << "query=\"" << query << "\", expected=\""
                                     << expected << "\"");
     const GURL url(MakeUrlWithQuery(query));
     const UrlSearchParamsView params(url);
     const std::string serialized = params.SerializeAsUtf8();
     EXPECT_EQ(serialized, expected);

     // Loop the result through GURL and UrlSearchParamsView again to verify it
     // is unchanged. This property is not strictly necessary, but it is a useful
     // way to guarantee that the output is SerializeAsUtf8() is an injective
     // mapping w.r.t. UrlSearchParamsView objects.
     const GURL url_from_serialized(MakeUrlWithQuery(serialized));
     const UrlSearchParamsView recreated_params(url_from_serialized);
     EXPECT_EQ(recreated_params.SerializeAsUtf8(), serialized);
   }
 }

 }  // namespace
 }  // namespace net
	// Copyright 2025 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "net/base/url_search_params_view.h"

	#include <string>
	#include <vector>

	#include "base/containers/flat_map.h"
	#include "base/strings/strcat.h"
	#include "base/strings/string_util.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "url/gurl.h"

	namespace net {
	namespace {

	using ::testing::ElementsAre;
	using ::testing::Pair;

	TEST(UrlSearchParamsViewTest, ParseAllSearchParams) {
	const GURL url("https://a.test/index.html?a=1&b=2&c=3");
	const UrlSearchParamsView search_params(url);
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("a", "1"), Pair("b", "2"), Pair("c", "3")));
	}

	TEST(UrlSearchParamsViewTest, ParseSearchParamUnescapeValue) {
	const GURL url(R"(https://a.test/index.html?a=a%20b%20c)");
	const UrlSearchParamsView search_params(url);
	EXPECT_EQ(search_params.GetDecodedParamsForTesting().size(), 1u);
	EXPECT_EQ(search_params.GetDecodedParamsForTesting()[0].second, "a b c");
	}

	TEST(UrlSearchParamsViewTest, DeleteOneSearchParams) {
	const GURL url("https://a.test/index.html?a=1&b=2&c=3");
	UrlSearchParamsView search_params(url);
	search_params.DeleteAllWithNames({"b"});
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("a", "1"), Pair("c", "3")));
	}

	TEST(UrlSearchParamsViewTest, DeleteAllExceptOneSearchParams) {
	const GURL url("https://a.test/index.html?a=1&b=2&c=3");
	UrlSearchParamsView search_params(url);
	search_params.DeleteAllExceptWithNames({"b"});
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("b", "2")));
	}

	TEST(UrlSearchParamsViewTest, SortSearchParams) {
	const GURL url("https://a.test/index.html?c=3&b=2&a=1&c=2&a=5");
	UrlSearchParamsView search_params(url);
	search_params.Sort();
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("a", "1"), Pair("a", "5"), Pair("b", "2"),
	Pair("c", "3"), Pair("c", "2")));
	}

	TEST(UrlSearchParamsViewTest, SortSearchParamsPercentEncoded) {
	const GURL url("https://a.test/index.html?c=3&b=2&a=1&%63=2&a=5");
	UrlSearchParamsView search_params(url);
	search_params.Sort();
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("a", "1"), Pair("a", "5"), Pair("b", "2"),
	Pair("c", "3"), Pair("c", "2")));
	}

	TEST(UrlSearchParamsViewTest, ParseSearchParamsSpacePlusAndPercentEncoded) {
	const GURL url(
	R"(https://a.test/index.html?c+1=3&b+%202=2&a=1&%63%201=2&a=5)");
	const UrlSearchParamsView search_params(url);
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("c 1", "3"), Pair("b 2", "2"), Pair("a", "1"),
	Pair("c 1", "2"), Pair("a", "5")));
	}

	TEST(UrlSearchParamsViewTest, ParseSearchParamsDoubleCodePoint) {
	const GURL url(R"(https://a.test/index.html?%C3%A9=foo)");
	const UrlSearchParamsView search_params(url);
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("é", "foo")));
	}

	TEST(UrlSearchParamsViewTest, SortSearchParamsDoubleCodePoint) {
	const GURL url(R"(https://a.test/index.html?%C3%A9=f&a=2&c=4&é=b)");
	UrlSearchParamsView search_params(url);
	search_params.Sort();
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("a", "2"), Pair("c", "4"), Pair("é", "f"),
	Pair("é", "b")));
	}

	TEST(UrlSearchParamsViewTest, ParseSearchParamsTripleCodePoint) {
	const GURL url(R"(https://a.test/index.html?%E3%81%81=foo)");
	const UrlSearchParamsView search_params(url);
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("ぁ", "foo")));
	}

	TEST(UrlSearchParamsViewTest, ParseSearchParamsQuadrupleCodePoint) {
	const GURL url(R"(https://a.test/index.html?%F0%90%A8%80=foo)");
	const UrlSearchParamsView search_params(url);
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("𐨀", "foo")));
	}

	// In case an invalid UTF-8 sequence is entered, it would be replaced with
	// the U+FFFD REPLACEMENT CHARACTER: �.
	TEST(UrlSearchParamsViewTest, ParseSearchParamsInvalidCodePoint) {
	const GURL url(R"(https://a.test/index.html?%C3=foo)");
	const UrlSearchParamsView search_params(url);
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("�", "foo")));
	}

	TEST(UrlSearchParamsViewTest, ParseSearchParamsSpecialCharacters) {
	// Use special characters in both `keys` and `values`.
	const base::flat_map<std::string, std::string> percent_encoding = {
	{"!", "%21"}, {R"(")", "%22"}, // double quote character: "
	{"#", "%23"}, {"$", "%24"}, {"%", "%25"}, {"&", "%26"},
	{"'", "%27"}, {"(", "%28"}, {")", "%29"}, {"*", R"(%2A)"},
	{"+", R"(%2B)"}, {",", R"(%2C)"}, {"-", R"(%2D)"}, {".", R"(%2E)"},
	{"/", R"(%2F)"}, {":", R"(%3A)"}, {";", "%3B"}, {"<", R"(%3C)"},
	{"=", R"(%3D)"}, {">", R"(%3E)"}, {"?", R"(%3F)"}, {"@", "%40"},
	{"[", "%5B"}, {R"(\)", R"(%5C)"}, {"]", R"(%5D)"}, {"^", R"(%5E)"},
	{"_", R"(%5F)"}, {"`", "%60"}, {"{", "%7B"}, {"\|", R"(%7C)"},
	{"}", R"(%7D)"}, {"~", R"(%7E)"}, {"", ""},
	};

	for (const auto& [key, value] : percent_encoding) {
	std::string template_url = R"(https://a.test/index.html?$key=$value)";

	base::ReplaceSubstringsAfterOffset(&template_url, 0, "$key", value);
	base::ReplaceSubstringsAfterOffset(&template_url, 0, "$value", value);

	const GURL url(template_url);
	const UrlSearchParamsView search_params = UrlSearchParamsView(url);
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair(key, key)));
	}
	}

	TEST(UrlSearchParamsViewTest, ParseSearchParamsEmptyKeyOrValues) {
	const GURL url("https://a.test/index.html?a&b&c&d&=5&=1");
	const UrlSearchParamsView search_params(url);
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("a", ""), Pair("b", ""), Pair("c", ""),
	Pair("d", ""), Pair("", "5"), Pair("", "1")));
	}

	TEST(UrlSearchParamsViewTest, ParseSearchParamsInvalidEscapeTest) {
	const GURL url(R"(https://a.test/index.html?a=%3&%3=b)");
	const UrlSearchParamsView search_params(url);
	EXPECT_THAT(search_params.GetDecodedParamsForTesting(),
	ElementsAre(Pair("a", "%3"), Pair("%3", "b")));
	}

	struct QueryPair {
	std::string_view query_a;
	std::string_view query_b;
	};

	GURL MakeUrlWithQuery(std::string_view query) {
	// The trailing "#" makes GURL preserve trailing spaces. It doesn't form part
	// of the query and makes no difference in other cases.
	return GURL(base::StrCat({"http://a.test/?", query, "#"}));
	}

	TEST(UrlSearchParamsViewTest, Equals) {
	static constexpr QueryPair kEqualsCases[] = {
	{"a", "a="},
	{"a=+", "a=%20"},
	{"=&", "="},
	{"%61=%62", "a=b"},
	{"%c0=%c1", "%c1=%c0"},
	{"%61=1&a=2", "a=1&%61=2"},
	{"a=5&b=%6", "a=5&b=%6"},
	};

	for (const auto& [query_a, query_b] : kEqualsCases) {
	const GURL url_a = MakeUrlWithQuery(query_a);
	const GURL url_b = MakeUrlWithQuery(query_b);
	const UrlSearchParamsView search_params_a(url_a);
	const UrlSearchParamsView search_params_b(url_b);
	EXPECT_EQ(search_params_a, search_params_b)
	<< "a=" << url_a << ", b=" << url_b;
	}
	}

	TEST(UrlSearchParamsViewTest, NotEquals) {
	static constexpr QueryPair kNotEqualsCases[] = {
	{"a=1&a=2", "a=2&a=1"},
	{"a=%c2%a2", "a=%c2%a3"},
	{"a", "b"},
	{"%c2%a2", "%c2%a3"},
	{"=&=", "="},
	{"A=0", "a=0"},
	{"%cO=1", "%co=1"},
	{"%c0=", "=%c0"},
	};

	for (const auto& [query_a, query_b] : kNotEqualsCases) {
	const GURL url_a = MakeUrlWithQuery(query_a);
	const GURL url_b = MakeUrlWithQuery(query_b);
	const UrlSearchParamsView search_params_a(url_a);
	const UrlSearchParamsView search_params_b(url_b);
	EXPECT_NE(search_params_a, search_params_b)
	<< "a=" << url_a << ", b=" << url_b;
	}
	}

	TEST(UrlSearchParamsViewTest, SerializeAsUtf8WithNoQuery) {
	const GURL no_query("http://a.test/");
	const UrlSearchParamsView params(no_query);
	EXPECT_EQ(params.SerializeAsUtf8(), "");
	}

	TEST(UrlSearchParamsViewTest, SerializeAsUtf8Cases) {
	static constexpr std::string_view kNulEqualsNul("\0=\0", 3);
	static constexpr QueryPair kQueryAndExpected[] = {
	{"", ""},
	{"a", "a="},
	{"&", "="},
	{"&b", "=&b="},
	{"&&", "=&="},
	{"a==b", "a=%3Db"},
	{"%3d=b", "%3D=b"},
	{"%26&=%26", "%26=&=%26"}, // '&' is escaped in keys and values
	{"+=+", " = "}, // ' ' is not escaped
	{"%20=+%20+", " = "}, // %20 is ' '
	{"%=%", "%25=%25"}, // Invalid escape is made valid
	{"%23=%23", "%23=%23"}, // '#' is escaped
	{kNulEqualsNul, "%00=%00"}, // '\0' is escaped
	{"%c2%a5", "\xc2\xa5="}, // Valid UTF-8 is not escaped
	{"=%c2%a5", "=\xc2\xa5"},
	{"%c2=%a5", "\xef\xbf\xbd=\xef\xbf\xbd"}, // Invalid UTF-8
	};
	for (const auto& [query, expected] : kQueryAndExpected) {
	SCOPED_TRACE(testing::Message() << "query=\"" << query << "\", expected=\""
	<< expected << "\"");
	const GURL url(MakeUrlWithQuery(query));
	const UrlSearchParamsView params(url);
	const std::string serialized = params.SerializeAsUtf8();
	EXPECT_EQ(serialized, expected);

	// Loop the result through GURL and UrlSearchParamsView again to verify it
	// is unchanged. This property is not strictly necessary, but it is a useful
	// way to guarantee that the output is SerializeAsUtf8() is an injective
	// mapping w.r.t. UrlSearchParamsView objects.
	const GURL url_from_serialized(MakeUrlWithQuery(serialized));
	const UrlSearchParamsView recreated_params(url_from_serialized);
	EXPECT_EQ(recreated_params.SerializeAsUtf8(), serialized);
	}
	}

	} // namespace
	} // namespace net