blob: 77bcd6d3769217e565ef3f043bcbbfd8b419ed17 [file] [log] [blame]
// Copyright 2013 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 "src/lib/url/url_util.h"
#include <gtest/gtest.h>
#include "src/lib/fxl/macros.h"
#include "src/lib/url/third_party/mozilla/url_parse.h"
#include "src/lib/url/url_canon.h"
#include "src/lib/url/url_canon_stdstring.h"
#include "src/lib/url/url_test_utils.h"
namespace url {
TEST(URLUtilTest, FindAndCompareScheme) {
Component found_scheme;
// Simple case where the scheme is found and matches.
const char kStr1[] = "";
EXPECT_TRUE(FindAndCompareScheme(kStr1, static_cast<int>(strlen(kStr1)), "http", NULL));
EXPECT_TRUE(FindAndCompareScheme(kStr1, static_cast<int>(strlen(kStr1)), "http", &found_scheme));
EXPECT_TRUE(found_scheme == Component(0, 4));
// A case where the scheme is found and doesn't match.
FindAndCompareScheme(kStr1, static_cast<int>(strlen(kStr1)), "https", &found_scheme));
EXPECT_TRUE(found_scheme == Component(0, 4));
// A case where there is no scheme.
const char kStr2[] = "httpfoobar";
EXPECT_FALSE(FindAndCompareScheme(kStr2, static_cast<int>(strlen(kStr2)), "http", &found_scheme));
EXPECT_TRUE(found_scheme == Component());
// When there is an empty scheme, it should match the empty scheme.
const char kStr3[] = "";
EXPECT_TRUE(FindAndCompareScheme(kStr3, static_cast<int>(strlen(kStr3)), "", &found_scheme));
EXPECT_TRUE(found_scheme == Component(0, 0));
// But when there is no scheme, it should fail.
EXPECT_FALSE(FindAndCompareScheme("", 0, "", &found_scheme));
EXPECT_TRUE(found_scheme == Component());
// When there is a whitespace char in scheme, it should canonicalize the URL
// before comparison.
const char whtspc_str[] = " \r\n\tjav\ra\nscri\tpt:alert(1)";
EXPECT_TRUE(FindAndCompareScheme(whtspc_str, static_cast<int>(strlen(whtspc_str)), "javascript",
EXPECT_TRUE(found_scheme == Component(1, 10));
// Control characters should be stripped out on the ends, and kept in the
// middle.
const char ctrl_str[] = "\02jav\02scr\03ipt:alert(1)";
EXPECT_FALSE(FindAndCompareScheme(ctrl_str, static_cast<int>(strlen(ctrl_str)), "javascript",
EXPECT_TRUE(found_scheme == Component(1, 11));
TEST(URLUtilTest, TestEncodeURIComponent) {
struct EncodeCase {
const char* input;
const char* output;
} encode_cases[] = {
{"hello, world", "hello%2C%20world"},
{" !\"#$%&'()*+,-./", "%20!%22%23%24%25%26%27()*%2B%2C-.%2F"},
{"0123456789:;<=>?", "0123456789%3A%3B%3C%3D%3E%3F"},
{"`abcdefghijklmno", "%60abcdefghijklmno"},
{"pqrstuvwxyz{|}~\x7f", "pqrstuvwxyz%7B%7C%7D~%7F"},
for (const auto& encode_case : encode_cases) {
const char* input = encode_case.input;
RawCanonOutputT<char> buffer;
EncodeURIComponent(input, strlen(input), &buffer);
std::string output(, buffer.length());
EXPECT_EQ(encode_case.output, output);
TEST(URLUtilTest, TestResolveRelativeWithNonStandardBase) {
// This tests non-standard (in the sense that GIsStandard() == false)
// hierarchical schemes.
struct ResolveRelativeCase {
const char* base;
const char* rel;
bool is_valid;
const char* out;
} resolve_non_standard_cases[] = {
// Resolving a relative path against a non-hierarchical URL should fail.
{"scheme:opaque_data", "/path", false, ""},
// Resolving a relative path against a non-standard authority-based base
// URL doesn't alter the authority section.
{"scheme://Authority/", "../path", true, "scheme://Authority/path"},
// A non-standard hierarchical base is resolved with path URL
// canonicalization rules.
{"data:/Blah:Blah/", "file.html", true, "data:/Blah:Blah/file.html"},
{"data:/Path/../part/part2", "file.html", true, "data:/Path/../part/file.html"},
// Path URL canonicalization rules also apply to non-standard authority-
// based URLs.
{"custom://Authority/", "file.html", true, "custom://Authority/file.html"},
{"custom://Authority/", "other://Auth/", true, "other://Auth/"},
{"custom://Authority/", "../../file.html", true, "custom://Authority/file.html"},
{"custom://Authority/path/", "file.html", true, "custom://Authority/path/file.html"},
{"custom://Authority:NoCanon/path/", "file.html", true,
// It's still possible to get an invalid path URL.
{"custom://Invalid:!#Auth/", "file.html", false, ""},
// A path with an authority section gets canonicalized under standard URL
// rules, even though the base was non-standard.
{"content://content.Provider/", "//other.Provider", true, "content://other.provider/"},
// Resolving an absolute URL doesn't cause canonicalization of the
// result.
{"about:blank", "custom://Authority", true, "custom://Authority"},
// Fragment URLs can be resolved against a non-standard base.
{"scheme://Authority/path", "#fragment", true, "scheme://Authority/path#fragment"},
{"scheme://Authority/", "#fragment", true, "scheme://Authority/#fragment"},
// Resolving should fail if the base URL is authority-based but is
// missing a path component (the '/' at the end).
{"scheme://Authority", "path", false, ""},
// Test resolving a fragment (only) against any kind of base-URL.
{"about:blank", "#id42", true, "about:blank#id42"},
{"about:blank", " #id42", true, "about:blank#id42"},
{"about:blank#oldfrag", "#newfrag", true, "about:blank#newfrag"},
// A surprising side effect of allowing fragments to resolve against
// any URL scheme is we might break javascript: URLs by doing so...
{"javascript:alert('foo#bar')", "#badfrag", true, "javascript:alert('foo#badfrag"},
// In this case, the backslashes will not be canonicalized because it's a
// non-standard URL, but they will be treated as a path separators,
// giving the base URL here a path of "\".
// The result here is somewhat arbitrary. One could argue it should be
// either "aaa://a\" or "aaa://a/" since the path is being replaced with
// the "current directory". But in the context of resolving on data URLs,
// adding the requested dot doesn't seem wrong either.
{"aaa://a\\", "aaa:.", true, "aaa://a\\."}};
for (const auto& test_data : resolve_non_standard_cases) {
Parsed base_parsed;
ParsePathURL(test_data.base, strlen(test_data.base), false, &base_parsed);
std::string resolved;
StdStringCanonOutput output(&resolved);
Parsed resolved_parsed;
bool valid = ResolveRelative(test_data.base, strlen(test_data.base), base_parsed, test_data.rel,
strlen(test_data.rel), NULL, &output, &resolved_parsed);
EXPECT_EQ(test_data.is_valid, valid);
if (test_data.is_valid && valid)
EXPECT_EQ(test_data.out, resolved);
TEST(URLUtilTest, TestNoRefComponent) {
// The hash-mark must be ignored when mailto: scheme is parsed,
// even if the URL has a base and relative part.
const char* base = "mailto://to/";
const char* rel = "any#body";
Parsed base_parsed;
ParsePathURL(base, strlen(base), false, &base_parsed);
std::string resolved;
StdStringCanonOutput output(&resolved);
Parsed resolved_parsed;
bool valid = ResolveRelative(base, strlen(base), base_parsed, rel, strlen(rel), NULL, &output,
} // namespace url