|  | @@ -23,81 +23,113 @@
 | 
	
		
			
				|  |  |  #include "absl/strings/str_join.h"
 | 
	
		
			
				|  |  |  #include "absl/strings/str_split.h"
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +#include <gmock/gmock.h>
 | 
	
		
			
				|  |  |  #include <grpc/grpc.h>
 | 
	
		
			
				|  |  |  #include <grpc/support/log.h>
 | 
	
		
			
				|  |  | +#include <gtest/gtest.h>
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  #include "test/core/util/test_config.h"
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -static void test_succeeds(
 | 
	
		
			
				|  |  | +using ::testing::ContainerEq;
 | 
	
		
			
				|  |  | +using ::testing::Contains;
 | 
	
		
			
				|  |  | +using ::testing::ElementsAre;
 | 
	
		
			
				|  |  | +using ::testing::Pair;
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +static void TestSucceeds(
 | 
	
		
			
				|  |  |      absl::string_view uri_text, absl::string_view scheme,
 | 
	
		
			
				|  |  |      absl::string_view authority, absl::string_view path,
 | 
	
		
			
				|  |  | -    const std::map<std::string, std::string>& query_param_map,
 | 
	
		
			
				|  |  | -    const std::vector<grpc_core::URI::QueryParam> query_param_pairs,
 | 
	
		
			
				|  |  | +    const std::map<absl::string_view, absl::string_view>& query_param_map,
 | 
	
		
			
				|  |  | +    const std::vector<grpc_core::URI::QueryParam>& query_param_pairs,
 | 
	
		
			
				|  |  |      absl::string_view fragment) {
 | 
	
		
			
				|  |  |    absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Parse(uri_text);
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri.ok());
 | 
	
		
			
				|  |  | -  GPR_ASSERT(scheme == uri->scheme());
 | 
	
		
			
				|  |  | -  GPR_ASSERT(authority == uri->authority());
 | 
	
		
			
				|  |  | -  GPR_ASSERT(path == uri->path());
 | 
	
		
			
				|  |  | -  // query param map
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri->query_parameter_map().size() == query_param_map.size());
 | 
	
		
			
				|  |  | -  for (const auto& expected_kv : query_param_map) {
 | 
	
		
			
				|  |  | -    const auto it = uri->query_parameter_map().find(expected_kv.first);
 | 
	
		
			
				|  |  | -    GPR_ASSERT(it != uri->query_parameter_map().end());
 | 
	
		
			
				|  |  | -    GPR_ASSERT(it->second == expected_kv.second);
 | 
	
		
			
				|  |  | -  }
 | 
	
		
			
				|  |  | -  // query param pairs
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri->query_parameter_pairs() == query_param_pairs);
 | 
	
		
			
				|  |  | -  GPR_ASSERT(fragment == uri->fragment());
 | 
	
		
			
				|  |  | +  ASSERT_TRUE(uri.ok());
 | 
	
		
			
				|  |  | +  EXPECT_EQ(scheme, uri->scheme());
 | 
	
		
			
				|  |  | +  EXPECT_EQ(authority, uri->authority());
 | 
	
		
			
				|  |  | +  EXPECT_EQ(path, uri->path());
 | 
	
		
			
				|  |  | +  EXPECT_THAT(uri->query_parameter_map(), ContainerEq(query_param_map));
 | 
	
		
			
				|  |  | +  EXPECT_THAT(uri->query_parameter_pairs(), ContainerEq(query_param_pairs));
 | 
	
		
			
				|  |  | +  EXPECT_EQ(fragment, uri->fragment());
 | 
	
		
			
				|  |  |  }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -static void test_fails(absl::string_view uri_text) {
 | 
	
		
			
				|  |  | +static void TestFails(absl::string_view uri_text) {
 | 
	
		
			
				|  |  |    absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Parse(uri_text);
 | 
	
		
			
				|  |  | -  GPR_ASSERT(!uri.ok());
 | 
	
		
			
				|  |  | +  ASSERT_FALSE(uri.ok());
 | 
	
		
			
				|  |  |  }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -static void test_query_param_map() {
 | 
	
		
			
				|  |  | -  test_succeeds("http://localhost:8080/whatzit?mi_casa=su_casa", "http",
 | 
	
		
			
				|  |  | -                "localhost:8080", "/whatzit", {{"mi_casa", "su_casa"}},
 | 
	
		
			
				|  |  | -                {{"mi_casa", "su_casa"}}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("http://localhost:8080/whatzit?1=2#buckle/my/shoe", "http",
 | 
	
		
			
				|  |  | -                "localhost:8080", "/whatzit", {{"1", "2"}}, {{"1", "2"}},
 | 
	
		
			
				|  |  | -                "buckle/my/shoe");
 | 
	
		
			
				|  |  | -  test_succeeds(
 | 
	
		
			
				|  |  | +TEST(URIParserTest, BasicExamplesAreParsedCorrectly) {
 | 
	
		
			
				|  |  | +  TestSucceeds("http://www.google.com", "http", "www.google.com", "", {}, {},
 | 
	
		
			
				|  |  | +               "");
 | 
	
		
			
				|  |  | +  TestSucceeds("dns:///foo", "dns", "", "/foo", {}, {}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("http://www.google.com:90", "http", "www.google.com:90", "", {},
 | 
	
		
			
				|  |  | +               {}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("a192.4-df:foo.coom", "a192.4-df", "", "foo.coom", {}, {}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("a+b:foo.coom", "a+b", "", "foo.coom", {}, {}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("zookeeper://127.0.0.1:2181/foo/bar", "zookeeper",
 | 
	
		
			
				|  |  | +               "127.0.0.1:2181", "/foo/bar", {}, {}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("dns:foo.com#fragment-all-the-things", "dns", "", "foo.com", {},
 | 
	
		
			
				|  |  | +               {}, "fragment-all-the-things");
 | 
	
		
			
				|  |  | +  TestSucceeds("http://localhost:8080/whatzit?mi_casa=su_casa", "http",
 | 
	
		
			
				|  |  | +               "localhost:8080", "/whatzit", {{"mi_casa", "su_casa"}},
 | 
	
		
			
				|  |  | +               {{"mi_casa", "su_casa"}}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("http://localhost:8080/whatzit?1=2#buckle/my/shoe", "http",
 | 
	
		
			
				|  |  | +               "localhost:8080", "/whatzit", {{"1", "2"}}, {{"1", "2"}},
 | 
	
		
			
				|  |  | +               "buckle/my/shoe");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, UncommonValidExamplesAreParsedCorrectly) {
 | 
	
		
			
				|  |  | +  TestSucceeds("scheme:path//is/ok", "scheme", "", "path//is/ok", {}, {}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("http:?legit", "http", "", "", {{"legit", ""}}, {{"legit", ""}},
 | 
	
		
			
				|  |  | +               "");
 | 
	
		
			
				|  |  | +  TestSucceeds("unix:#this-is-ok-too", "unix", "", "", {}, {},
 | 
	
		
			
				|  |  | +               "this-is-ok-too");
 | 
	
		
			
				|  |  | +  TestSucceeds("http:?legit#twice", "http", "", "", {{"legit", ""}},
 | 
	
		
			
				|  |  | +               {{"legit", ""}}, "twice");
 | 
	
		
			
				|  |  | +  TestSucceeds("fake:///", "fake", "", "/", {}, {}, "");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, VariousKeyValueAndNonKVQueryParamsAreParsedCorrectly) {
 | 
	
		
			
				|  |  | +  TestSucceeds("http://foo/path?a&b=B&c=&#frag", "http", "foo", "/path",
 | 
	
		
			
				|  |  | +               {{"c", ""}, {"a", ""}, {"b", "B"}},
 | 
	
		
			
				|  |  | +               {{"a", ""}, {"b", "B"}, {"c", ""}}, "frag");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, ParserTreatsFirstEqualSignAsKVDelimiterInQueryString) {
 | 
	
		
			
				|  |  | +  TestSucceeds(
 | 
	
		
			
				|  |  |        "http://localhost:8080/?too=many=equals&are=present=here#fragged", "http",
 | 
	
		
			
				|  |  |        "localhost:8080", "/", {{"are", "present=here"}, {"too", "many=equals"}},
 | 
	
		
			
				|  |  |        {{"too", "many=equals"}, {"are", "present=here"}}, "fragged");
 | 
	
		
			
				|  |  | -  test_succeeds("http://foo/path?a&b=B&c=&#frag", "http", "foo", "/path",
 | 
	
		
			
				|  |  | -                {{"c", ""}, {"a", ""}, {"b", "B"}},
 | 
	
		
			
				|  |  | -                {{"a", ""}, {"b", "B"}, {"c", ""}}, "frag");
 | 
	
		
			
				|  |  | -  test_succeeds("http://auth/path?foo=bar=baz&foobar===", "http", "auth",
 | 
	
		
			
				|  |  | -                "/path", {{"foo", "bar=baz"}, {"foobar", "=="}},
 | 
	
		
			
				|  |  | -                {{"foo", "bar=baz"}, {"foobar", "=="}}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("http://auth/path?foo=bar=baz&foobar===", "http", "auth",
 | 
	
		
			
				|  |  | +               "/path", {{"foo", "bar=baz"}, {"foobar", "=="}},
 | 
	
		
			
				|  |  | +               {{"foo", "bar=baz"}, {"foobar", "=="}}, "");
 | 
	
		
			
				|  |  |  }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -static void test_repeated_query_param_pairs() {
 | 
	
		
			
				|  |  | +TEST(URIParserTest,
 | 
	
		
			
				|  |  | +     RepeatedQueryParamsAreSupportedInOrderedPairsButDeduplicatedInTheMap) {
 | 
	
		
			
				|  |  |    absl::StatusOr<grpc_core::URI> uri =
 | 
	
		
			
				|  |  |        grpc_core::URI::Parse("http://foo/path?a=2&a=1&a=3");
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri.ok());
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri->query_parameter_map().size() == 1);
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri->query_parameter_map().find("a")->second == "3");
 | 
	
		
			
				|  |  | -  std::vector<grpc_core::URI::QueryParam> expected(
 | 
	
		
			
				|  |  | -      {{"a", "2"}, {"a", "1"}, {"a", "3"}});
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri->query_parameter_pairs() == expected);
 | 
	
		
			
				|  |  | +  ASSERT_TRUE(uri.ok());
 | 
	
		
			
				|  |  | +  // The map stores the last found value.
 | 
	
		
			
				|  |  | +  ASSERT_THAT(uri->query_parameter_map(), ElementsAre(Pair("a", "3")));
 | 
	
		
			
				|  |  | +  // Order matters for query parameter pairs
 | 
	
		
			
				|  |  | +  ASSERT_THAT(uri->query_parameter_pairs(),
 | 
	
		
			
				|  |  | +              ElementsAre(grpc_core::URI::QueryParam{"a", "2"},
 | 
	
		
			
				|  |  | +                          grpc_core::URI::QueryParam{"a", "1"},
 | 
	
		
			
				|  |  | +                          grpc_core::URI::QueryParam{"a", "3"}));
 | 
	
		
			
				|  |  |  }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -static void test_query_param_validity_after_move() {
 | 
	
		
			
				|  |  | +TEST(URIParserTest, QueryParamMapRemainsValiditAfterMovingTheURI) {
 | 
	
		
			
				|  |  |    grpc_core::URI uri_copy;
 | 
	
		
			
				|  |  |    {
 | 
	
		
			
				|  |  |      absl::StatusOr<grpc_core::URI> uri =
 | 
	
		
			
				|  |  |          grpc_core::URI::Parse("http://foo/path?a=2&b=1&c=3");
 | 
	
		
			
				|  |  | -    GPR_ASSERT(uri.ok());
 | 
	
		
			
				|  |  | +    ASSERT_TRUE(uri.ok());
 | 
	
		
			
				|  |  |      uri_copy = std::move(*uri);
 | 
	
		
			
				|  |  |    }
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri_copy.query_parameter_map().find("a")->second == "2");
 | 
	
		
			
				|  |  | +  // ASSERT_EQ(uri_copy.query_parameter_map().find("a")->second, "2");
 | 
	
		
			
				|  |  | +  ASSERT_THAT(uri_copy.query_parameter_map(), Contains(Pair("a", "2")));
 | 
	
		
			
				|  |  |  }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -static void test_query_param_validity_after_copy() {
 | 
	
		
			
				|  |  | +TEST(URIParserTest, QueryParamMapRemainsValidAfterCopyingTheURI) {
 | 
	
		
			
				|  |  |    // Since the query parameter map points to objects stored in the param pair
 | 
	
		
			
				|  |  |    // vector, this test checks that the param map pointers remain valid after
 | 
	
		
			
				|  |  |    // a copy. Ideally {a,m}san will catch this if there's a problem.
 | 
	
	
		
			
				|  | @@ -106,56 +138,18 @@ static void test_query_param_validity_after_copy() {
 | 
	
		
			
				|  |  |    {
 | 
	
		
			
				|  |  |      absl::StatusOr<grpc_core::URI> del_uri =
 | 
	
		
			
				|  |  |          grpc_core::URI::Parse("http://foo/path?a=2&b=1&c=3");
 | 
	
		
			
				|  |  | -    GPR_ASSERT(del_uri.ok());
 | 
	
		
			
				|  |  | +    ASSERT_TRUE(del_uri.ok());
 | 
	
		
			
				|  |  |      uri_copy = *del_uri;
 | 
	
		
			
				|  |  |    }
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri_copy.query_parameter_map().find("a")->second == "2");
 | 
	
		
			
				|  |  | -  // testing copy constructor:
 | 
	
		
			
				|  |  | +  ASSERT_THAT(uri_copy.query_parameter_map(), Contains(Pair("a", "2")));
 | 
	
		
			
				|  |  |    grpc_core::URI* del_uri2 = new grpc_core::URI(uri_copy);
 | 
	
		
			
				|  |  |    grpc_core::URI uri_copy2(*del_uri2);
 | 
	
		
			
				|  |  |    delete del_uri2;
 | 
	
		
			
				|  |  | -  GPR_ASSERT(uri_copy2.query_parameter_map().find("a")->second == "2");
 | 
	
		
			
				|  |  | +  ASSERT_THAT(uri_copy2.query_parameter_map(), Contains(Pair("a", "2")));
 | 
	
		
			
				|  |  |  }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -int main(int argc, char** argv) {
 | 
	
		
			
				|  |  | -  grpc::testing::TestEnvironment env(argc, argv);
 | 
	
		
			
				|  |  | -  grpc_init();
 | 
	
		
			
				|  |  | -  test_succeeds("http://www.google.com", "http", "www.google.com", "", {}, {},
 | 
	
		
			
				|  |  | -                "");
 | 
	
		
			
				|  |  | -  test_succeeds("dns:///foo", "dns", "", "/foo", {}, {}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("http://www.google.com:90", "http", "www.google.com:90", "", {},
 | 
	
		
			
				|  |  | -                {}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("a192.4-df:foo.coom", "a192.4-df", "", "foo.coom", {}, {}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("a+b:foo.coom", "a+b", "", "foo.coom", {}, {}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("zookeeper://127.0.0.1:2181/foo/bar", "zookeeper",
 | 
	
		
			
				|  |  | -                "127.0.0.1:2181", "/foo/bar", {}, {}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("http://www.google.com?yay-i'm-using-queries", "http",
 | 
	
		
			
				|  |  | -                "www.google.com", "", {{"yay-i'm-using-queries", ""}},
 | 
	
		
			
				|  |  | -                {{"yay-i'm-using-queries", ""}}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("dns:foo.com#fragment-all-the-things", "dns", "", "foo.com", {},
 | 
	
		
			
				|  |  | -                {}, "fragment-all-the-things");
 | 
	
		
			
				|  |  | -  test_succeeds("http:?legit", "http", "", "", {{"legit", ""}}, {{"legit", ""}},
 | 
	
		
			
				|  |  | -                "");
 | 
	
		
			
				|  |  | -  test_succeeds("unix:#this-is-ok-too", "unix", "", "", {}, {},
 | 
	
		
			
				|  |  | -                "this-is-ok-too");
 | 
	
		
			
				|  |  | -  test_succeeds("http:?legit#twice", "http", "", "", {{"legit", ""}},
 | 
	
		
			
				|  |  | -                {{"legit", ""}}, "twice");
 | 
	
		
			
				|  |  | -  test_succeeds("http://foo?bar#lol?", "http", "foo", "", {{"bar", ""}},
 | 
	
		
			
				|  |  | -                {{"bar", ""}}, "lol?");
 | 
	
		
			
				|  |  | -  test_succeeds("http://foo?bar#lol?/", "http", "foo", "", {{"bar", ""}},
 | 
	
		
			
				|  |  | -                {{"bar", ""}}, "lol?/");
 | 
	
		
			
				|  |  | -  test_succeeds("ipv6:[2001:db8::1%252]:12345", "ipv6", "",
 | 
	
		
			
				|  |  | -                "[2001:db8::1%2]:12345", {}, {}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("ipv6:[fe80::90%eth1.sky1]:6010", "ipv6", "",
 | 
	
		
			
				|  |  | -                "[fe80::90%eth1.sky1]:6010", {}, {}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("https://www.google.com/?a=1%26b%3D2&c=3", "https",
 | 
	
		
			
				|  |  | -                "www.google.com", "/", {{"c", "3"}, {"a", "1&b=2"}},
 | 
	
		
			
				|  |  | -                {{"a", "1&b=2"}, {"c", "3"}}, "");
 | 
	
		
			
				|  |  | -  // Artificial examples to show that embedded nulls are supported.
 | 
	
		
			
				|  |  | -  test_succeeds(std::string("unix-abstract:\0should-be-ok", 27),
 | 
	
		
			
				|  |  | -                "unix-abstract", "", std::string("\0should-be-ok", 13), {}, {},
 | 
	
		
			
				|  |  | -                "");
 | 
	
		
			
				|  |  | -  test_succeeds(
 | 
	
		
			
				|  |  | +TEST(URIParserTest, AWSExternalAccountRegressionTest) {
 | 
	
		
			
				|  |  | +  TestSucceeds(
 | 
	
		
			
				|  |  |        "https://foo.com:5555/v1/"
 | 
	
		
			
				|  |  |        "token-exchange?subject_token=eyJhbGciO&subject_token_type=urn:ietf:"
 | 
	
		
			
				|  |  |        "params:oauth:token-type:id_token",
 | 
	
	
		
			
				|  | @@ -165,24 +159,68 @@ int main(int argc, char** argv) {
 | 
	
		
			
				|  |  |        {{"subject_token", "eyJhbGciO"},
 | 
	
		
			
				|  |  |         {"subject_token_type", "urn:ietf:params:oauth:token-type:id_token"}},
 | 
	
		
			
				|  |  |        "");
 | 
	
		
			
				|  |  | -  test_succeeds("http:?dangling-pct-%0", "http", "", "",
 | 
	
		
			
				|  |  | -                {{"dangling-pct-%0", ""}}, {{"dangling-pct-%0", ""}}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("unix-abstract:%00x", "unix-abstract", "",
 | 
	
		
			
				|  |  | -                std::string("\0x", 2), {}, {}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("x:y?%xx", "x", "", "y", {{"%xx", ""}}, {{"%xx", ""}}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("scheme:path//is/ok", "scheme", "", "path//is/ok", {}, {}, "");
 | 
	
		
			
				|  |  | -  test_succeeds("fake:///", "fake", "", "/", {}, {}, "");
 | 
	
		
			
				|  |  | -  test_fails("xyz");
 | 
	
		
			
				|  |  | -  test_fails("http://foo?[bar]");
 | 
	
		
			
				|  |  | -  test_fails("http://foo?x[bar]");
 | 
	
		
			
				|  |  | -  test_fails("http://foo?bar#lol#");
 | 
	
		
			
				|  |  | -  test_fails("");
 | 
	
		
			
				|  |  | -  test_fails(":no_scheme");
 | 
	
		
			
				|  |  | -  test_fails("0invalid_scheme:must_start/with?alpha");
 | 
	
		
			
				|  |  | -  test_query_param_map();
 | 
	
		
			
				|  |  | -  test_repeated_query_param_pairs();
 | 
	
		
			
				|  |  | -  test_query_param_validity_after_move();
 | 
	
		
			
				|  |  | -  test_query_param_validity_after_copy();
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, NonKeyValueQueryStringsWork) {
 | 
	
		
			
				|  |  | +  TestSucceeds("http://www.google.com?yay-i'm-using-queries", "http",
 | 
	
		
			
				|  |  | +               "www.google.com", "", {{"yay-i'm-using-queries", ""}},
 | 
	
		
			
				|  |  | +               {{"yay-i'm-using-queries", ""}}, "");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, IPV6StringsAreParsedCorrectly) {
 | 
	
		
			
				|  |  | +  TestSucceeds("ipv6:[2001:db8::1%252]:12345", "ipv6", "",
 | 
	
		
			
				|  |  | +               "[2001:db8::1%2]:12345", {}, {}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("ipv6:[fe80::90%eth1.sky1]:6010", "ipv6", "",
 | 
	
		
			
				|  |  | +               "[fe80::90%eth1.sky1]:6010", {}, {}, "");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, PreviouslyReservedCharactersInUnrelatedURIPartsAreIgnored) {
 | 
	
		
			
				|  |  | +  // The '?' and '/' characters are not reserved delimiter characters in the
 | 
	
		
			
				|  |  | +  // fragment. See http://go/rfc/3986#section-3.5
 | 
	
		
			
				|  |  | +  TestSucceeds("http://foo?bar#lol?", "http", "foo", "", {{"bar", ""}},
 | 
	
		
			
				|  |  | +               {{"bar", ""}}, "lol?");
 | 
	
		
			
				|  |  | +  TestSucceeds("http://foo?bar#lol?/", "http", "foo", "", {{"bar", ""}},
 | 
	
		
			
				|  |  | +               {{"bar", ""}}, "lol?/");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, EncodedCharactersInQueryStringAreParsedCorrectly) {
 | 
	
		
			
				|  |  | +  TestSucceeds("https://www.google.com/?a=1%26b%3D2&c=3", "https",
 | 
	
		
			
				|  |  | +               "www.google.com", "/", {{"c", "3"}, {"a", "1&b=2"}},
 | 
	
		
			
				|  |  | +               {{"a", "1&b=2"}, {"c", "3"}}, "");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, InvalidPercentEncodingsArePassedThrough) {
 | 
	
		
			
				|  |  | +  TestSucceeds("x:y?%xx", "x", "", "y", {{"%xx", ""}}, {{"%xx", ""}}, "");
 | 
	
		
			
				|  |  | +  TestSucceeds("http:?dangling-pct-%0", "http", "", "",
 | 
	
		
			
				|  |  | +               {{"dangling-pct-%0", ""}}, {{"dangling-pct-%0", ""}}, "");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, NullCharactersInURIStringAreSupported) {
 | 
	
		
			
				|  |  | +  // Artificial examples to show that embedded nulls are supported.
 | 
	
		
			
				|  |  | +  TestSucceeds(std::string("unix-abstract:\0should-be-ok", 27), "unix-abstract",
 | 
	
		
			
				|  |  | +               "", std::string("\0should-be-ok", 13), {}, {}, "");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, EncodedNullsInURIStringAreSupported) {
 | 
	
		
			
				|  |  | +  TestSucceeds("unix-abstract:%00x", "unix-abstract", "", std::string("\0x", 2),
 | 
	
		
			
				|  |  | +               {}, {}, "");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +TEST(URIParserTest, InvalidURIsResultInFailureStatuses) {
 | 
	
		
			
				|  |  | +  TestFails("xyz");
 | 
	
		
			
				|  |  | +  TestFails("http://foo?[bar]");
 | 
	
		
			
				|  |  | +  TestFails("http://foo?x[bar]");
 | 
	
		
			
				|  |  | +  TestFails("http://foo?bar#lol#");
 | 
	
		
			
				|  |  | +  TestFails("");
 | 
	
		
			
				|  |  | +  TestFails(":no_scheme");
 | 
	
		
			
				|  |  | +  TestFails("0invalid_scheme:must_start/with?alpha");
 | 
	
		
			
				|  |  | +}
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +int main(int argc, char** argv) {
 | 
	
		
			
				|  |  | +  testing::InitGoogleTest(&argc, argv);
 | 
	
		
			
				|  |  | +  grpc::testing::TestEnvironment env(argc, argv);
 | 
	
		
			
				|  |  | +  grpc_init();
 | 
	
		
			
				|  |  | +  auto result = RUN_ALL_TESTS();
 | 
	
		
			
				|  |  |    grpc_shutdown();
 | 
	
		
			
				|  |  | -  return 0;
 | 
	
		
			
				|  |  | +  return result;
 | 
	
		
			
				|  |  |  }
 |