Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1393)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: scheme_host_port_unittest.cc

Issue 2029803003: Update to Chromium //url at Chromium commit 79dc59ac7602413181079ecb463873e29a1d7d0a. (Closed) Base URL: https://chromium.googlesource.com/external/github.com/domokit/gurl@master
Patch Set: Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « scheme_host_port.cc ('k') | third_party/mozilla/url_parse.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: scheme_host_port_unittest.cc
diff --git a/scheme_host_port_unittest.cc b/scheme_host_port_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..817631d74fdabb8eebe08ab693214e9206ab4e5f
--- /dev/null
+++ b/scheme_host_port_unittest.cc
@@ -0,0 +1,215 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+#include "url/scheme_host_port.h"
+
+namespace {
+
+TEST(SchemeHostPortTest, Invalid) {
+ url::SchemeHostPort invalid;
+ EXPECT_EQ("", invalid.scheme());
+ EXPECT_EQ("", invalid.host());
+ EXPECT_EQ(0, invalid.port());
+ EXPECT_TRUE(invalid.IsInvalid());
+ EXPECT_TRUE(invalid.Equals(invalid));
+
+ const char* urls[] = {"data:text/html,Hello!",
+ "javascript:alert(1)",
+ "file://example.com:443/etc/passwd",
+ "blob:https://example.com/uuid-goes-here",
+ "filesystem:https://example.com/temporary/yay.png"};
+
+ for (const auto& test : urls) {
+ SCOPED_TRACE(test);
+ GURL url(test);
+ url::SchemeHostPort tuple(url);
+ EXPECT_EQ("", tuple.scheme());
+ EXPECT_EQ("", tuple.host());
+ EXPECT_EQ(0, tuple.port());
+ EXPECT_TRUE(tuple.IsInvalid());
+ EXPECT_TRUE(tuple.Equals(tuple));
+ EXPECT_TRUE(tuple.Equals(invalid));
+ EXPECT_TRUE(invalid.Equals(tuple));
+ }
+}
+
+TEST(SchemeHostPortTest, ExplicitConstruction) {
+ struct TestCases {
+ const char* scheme;
+ const char* host;
+ uint16 port;
+ } cases[] = {
+ {"http", "example.com", 80},
+ {"http", "example.com", 123},
+ {"https", "example.com", 443},
+ {"https", "example.com", 123},
+ {"file", "", 0},
+ {"file", "example.com", 0},
+ };
+
+ for (const auto& test : cases) {
+ SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
+ << test.port);
+ url::SchemeHostPort tuple(test.scheme, test.host, test.port);
+ EXPECT_EQ(test.scheme, tuple.scheme());
+ EXPECT_EQ(test.host, tuple.host());
+ EXPECT_EQ(test.port, tuple.port());
+ EXPECT_FALSE(tuple.IsInvalid());
+ EXPECT_TRUE(tuple.Equals(tuple));
+ }
+}
+
+TEST(SchemeHostPortTest, InvalidConstruction) {
+ struct TestCases {
+ const char* scheme;
+ const char* host;
+ uint16 port;
+ } cases[] = {{"", "", 0},
+ {"data", "", 0},
+ {"blob", "", 0},
+ {"filesystem", "", 0},
+ {"http", "", 80},
+ {"data", "example.com", 80},
+ {"http", "☃.net", 80},
+ {"http\nmore", "example.com", 80},
+ {"http\rmore", "example.com", 80},
+ {"http\n", "example.com", 80},
+ {"http\r", "example.com", 80},
+ {"http", "example.com\nnot-example.com", 80},
+ {"http", "example.com\rnot-example.com", 80},
+ {"http", "example.com\n", 80},
+ {"http", "example.com\r", 80},
+ {"http", "example.com", 0},
+ {"file", "", 80}};
+
+ for (const auto& test : cases) {
+ SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
+ << test.port);
+ url::SchemeHostPort tuple(test.scheme, test.host, test.port);
+ EXPECT_EQ("", tuple.scheme());
+ EXPECT_EQ("", tuple.host());
+ EXPECT_EQ(0, tuple.port());
+ EXPECT_TRUE(tuple.IsInvalid());
+ EXPECT_TRUE(tuple.Equals(tuple));
+ }
+}
+
+TEST(SchemeHostPortTest, InvalidConstructionWithEmbeddedNulls) {
+ struct TestCases {
+ const char* scheme;
+ size_t scheme_length;
+ const char* host;
+ size_t host_length;
+ uint16 port;
+ } cases[] = {{"http\0more", 9, "example.com", 11, 80},
+ {"http\0", 5, "example.com", 11, 80},
+ {"\0http", 5, "example.com", 11, 80},
+ {"http", 4, "example.com\0not-example.com", 27, 80},
+ {"http", 4, "example.com\0", 12, 80},
+ {"http", 4, "\0example.com", 12, 80}};
+
+ for (const auto& test : cases) {
+ SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
+ << test.port);
+ url::SchemeHostPort tuple(std::string(test.scheme, test.scheme_length),
+ std::string(test.host, test.host_length),
+ test.port);
+ EXPECT_EQ("", tuple.scheme());
+ EXPECT_EQ("", tuple.host());
+ EXPECT_EQ(0, tuple.port());
+ EXPECT_TRUE(tuple.IsInvalid());
+ }
+}
+
+TEST(SchemeHostPortTest, GURLConstruction) {
+ struct TestCases {
+ const char* url;
+ const char* scheme;
+ const char* host;
+ uint16 port;
+ } cases[] = {
+ {"http://192.168.9.1/", "http", "192.168.9.1", 80},
+ {"http://[2001:db8::1]/", "http", "[2001:db8::1]", 80},
+ {"http://☃.net/", "http", "xn--n3h.net", 80},
+ {"http://example.com/", "http", "example.com", 80},
+ {"http://example.com:123/", "http", "example.com", 123},
+ {"https://example.com/", "https", "example.com", 443},
+ {"https://example.com:123/", "https", "example.com", 123},
+ {"file:///etc/passwd", "file", "", 0},
+ {"file://example.com/etc/passwd", "file", "example.com", 0},
+ {"http://u:p@example.com/", "http", "example.com", 80},
+ {"http://u:p@example.com/path", "http", "example.com", 80},
+ {"http://u:p@example.com/path?123", "http", "example.com", 80},
+ {"http://u:p@example.com/path?123#hash", "http", "example.com", 80},
+ };
+
+ for (const auto& test : cases) {
+ SCOPED_TRACE(test.url);
+ GURL url(test.url);
+ EXPECT_TRUE(url.is_valid());
+ url::SchemeHostPort tuple(url);
+ EXPECT_EQ(test.scheme, tuple.scheme());
+ EXPECT_EQ(test.host, tuple.host());
+ EXPECT_EQ(test.port, tuple.port());
+ EXPECT_FALSE(tuple.IsInvalid());
+ EXPECT_TRUE(tuple.Equals(tuple));
+ }
+}
+
+TEST(SchemeHostPortTest, Serialization) {
+ struct TestCases {
+ const char* url;
+ const char* expected;
+ } cases[] = {
+ {"http://192.168.9.1/", "http://192.168.9.1"},
+ {"http://[2001:db8::1]/", "http://[2001:db8::1]"},
+ {"http://☃.net/", "http://xn--n3h.net"},
+ {"http://example.com/", "http://example.com"},
+ {"http://example.com:123/", "http://example.com:123"},
+ {"https://example.com/", "https://example.com"},
+ {"https://example.com:123/", "https://example.com:123"},
+ {"file:///etc/passwd", "file://"},
+ {"file://example.com/etc/passwd", "file://example.com"},
+ };
+
+ for (const auto& test : cases) {
+ SCOPED_TRACE(test.url);
+ GURL url(test.url);
+ url::SchemeHostPort tuple(url);
+ EXPECT_EQ(test.expected, tuple.Serialize());
+ }
+}
+
+TEST(SchemeHostPortTest, Comparison) {
+ // These tuples are arranged in increasing order:
+ struct SchemeHostPorts {
+ const char* scheme;
+ const char* host;
+ uint16 port;
+ } tuples[] = {
+ {"http", "a", 80},
+ {"http", "b", 80},
+ {"https", "a", 80},
+ {"https", "b", 80},
+ {"http", "a", 81},
+ {"http", "b", 81},
+ {"https", "a", 81},
+ {"https", "b", 81},
+ };
+
+ for (size_t i = 0; i < arraysize(tuples); i++) {
+ url::SchemeHostPort current(tuples[i].scheme, tuples[i].host,
+ tuples[i].port);
+ for (size_t j = i; j < arraysize(tuples); j++) {
+ url::SchemeHostPort to_compare(tuples[j].scheme, tuples[j].host,
+ tuples[j].port);
+ EXPECT_EQ(i < j, current < to_compare) << i << " < " << j;
+ EXPECT_EQ(j < i, to_compare < current) << j << " < " << i;
+ }
+ }
+}
+
+} // namespace url
« no previous file with comments | « scheme_host_port.cc ('k') | third_party/mozilla/url_parse.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698