1// Copyright 2008, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8//     * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10//     * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14//     * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30#include "googleurl/src/url_canon.h"
31#include "googleurl/src/url_canon_stdstring.h"
32#include "googleurl/src/url_parse.h"
33#include "googleurl/src/url_test_utils.h"
34#include "googleurl/src/url_util.h"
35#include "testing/gtest/include/gtest/gtest.h"
36
37TEST(URLUtilTest, FindAndCompareScheme) {
38  url_parse::Component found_scheme;
39
40  // Simple case where the scheme is found and matches.
41  const char kStr1[] = "http://www.com/";
42  EXPECT_TRUE(url_util::FindAndCompareScheme(
43      kStr1, static_cast<int>(strlen(kStr1)), "http", NULL));
44  EXPECT_TRUE(url_util::FindAndCompareScheme(
45      kStr1, static_cast<int>(strlen(kStr1)), "http", &found_scheme));
46  EXPECT_TRUE(found_scheme == url_parse::Component(0, 4));
47
48  // A case where the scheme is found and doesn't match.
49  EXPECT_FALSE(url_util::FindAndCompareScheme(
50      kStr1, static_cast<int>(strlen(kStr1)), "https", &found_scheme));
51  EXPECT_TRUE(found_scheme == url_parse::Component(0, 4));
52
53  // A case where there is no scheme.
54  const char kStr2[] = "httpfoobar";
55  EXPECT_FALSE(url_util::FindAndCompareScheme(
56      kStr2, static_cast<int>(strlen(kStr2)), "http", &found_scheme));
57  EXPECT_TRUE(found_scheme == url_parse::Component());
58
59  // When there is an empty scheme, it should match the empty scheme.
60  const char kStr3[] = ":foo.com/";
61  EXPECT_TRUE(url_util::FindAndCompareScheme(
62      kStr3, static_cast<int>(strlen(kStr3)), "", &found_scheme));
63  EXPECT_TRUE(found_scheme == url_parse::Component(0, 0));
64
65  // But when there is no scheme, it should fail.
66  EXPECT_FALSE(url_util::FindAndCompareScheme("", 0, "", &found_scheme));
67  EXPECT_TRUE(found_scheme == url_parse::Component());
68
69  // When there is a whitespace char in scheme, it should canonicalize the url
70  // before comparison.
71  const char whtspc_str[] = " \r\n\tjav\ra\nscri\tpt:alert(1)";
72  EXPECT_TRUE(url_util::FindAndCompareScheme(
73      whtspc_str, static_cast<int>(strlen(whtspc_str)), "javascript",
74      &found_scheme));
75  EXPECT_TRUE(found_scheme == url_parse::Component(1, 10));
76
77  // Control characters should be stripped out on the ends, and kept in the
78  // middle.
79  const char ctrl_str[] = "\02jav\02scr\03ipt:alert(1)";
80  EXPECT_FALSE(url_util::FindAndCompareScheme(
81      ctrl_str, static_cast<int>(strlen(ctrl_str)), "javascript",
82      &found_scheme));
83  EXPECT_TRUE(found_scheme == url_parse::Component(1, 11));
84}
85
86TEST(URLUtilTest, ReplaceComponents) {
87  url_parse::Parsed parsed;
88  url_canon::RawCanonOutputT<char> output;
89  url_parse::Parsed new_parsed;
90
91  // Check that the following calls do not cause crash
92  url_canon::Replacements<char> replacements;
93  replacements.SetRef("test", url_parse::Component(0, 4));
94  url_util::ReplaceComponents(NULL, 0, parsed, replacements, NULL, &output,
95                              &new_parsed);
96  url_util::ReplaceComponents("", 0, parsed, replacements, NULL, &output,
97                              &new_parsed);
98  replacements.ClearRef();
99  replacements.SetHost("test", url_parse::Component(0, 4));
100  url_util::ReplaceComponents(NULL, 0, parsed, replacements, NULL, &output,
101                              &new_parsed);
102  url_util::ReplaceComponents("", 0, parsed, replacements, NULL, &output,
103                              &new_parsed);
104
105  replacements.ClearHost();
106  url_util::ReplaceComponents(NULL, 0, parsed, replacements, NULL, &output,
107                              &new_parsed);
108  url_util::ReplaceComponents("", 0, parsed, replacements, NULL, &output,
109                              &new_parsed);
110  url_util::ReplaceComponents(NULL, 0, parsed, replacements, NULL, &output,
111                              &new_parsed);
112  url_util::ReplaceComponents("", 0, parsed, replacements, NULL, &output,
113                              &new_parsed);
114}
115
116static std::string CheckReplaceScheme(const char* base_url,
117                                      const char* scheme) {
118  // Make sure the input is canonicalized.
119  url_canon::RawCanonOutput<32> original;
120  url_parse::Parsed original_parsed;
121  url_util::Canonicalize(base_url, strlen(base_url), NULL,
122                         &original, &original_parsed);
123
124  url_canon::Replacements<char> replacements;
125  replacements.SetScheme(scheme, url_parse::Component(0, strlen(scheme)));
126
127  std::string output_string;
128  url_canon::StdStringCanonOutput output(&output_string);
129  url_parse::Parsed output_parsed;
130  url_util::ReplaceComponents(original.data(), original.length(),
131                              original_parsed, replacements, NULL,
132                              &output, &output_parsed);
133
134  output.Complete();
135  return output_string;
136}
137
138TEST(URLUtilTest, ReplaceScheme) {
139  EXPECT_EQ("https://google.com/",
140            CheckReplaceScheme("http://google.com/", "https"));
141  EXPECT_EQ("file://google.com/",
142            CheckReplaceScheme("http://google.com/", "file"));
143  EXPECT_EQ("http://home/Build",
144            CheckReplaceScheme("file:///Home/Build", "http"));
145  EXPECT_EQ("javascript:foo",
146            CheckReplaceScheme("about:foo", "javascript"));
147  EXPECT_EQ("://google.com/",
148            CheckReplaceScheme("http://google.com/", ""));
149  EXPECT_EQ("http://google.com/",
150            CheckReplaceScheme("about:google.com", "http"));
151  EXPECT_EQ("http:", CheckReplaceScheme("", "http"));
152
153#ifdef WIN32
154  // Magic Windows drive letter behavior when converting to a file URL.
155  EXPECT_EQ("file:///E:/foo/",
156            CheckReplaceScheme("http://localhost/e:foo/", "file"));
157#endif
158
159  // This will probably change to "about://google.com/" when we fix
160  // http://crbug.com/160 which should also be an acceptable result.
161  EXPECT_EQ("about://google.com/",
162            CheckReplaceScheme("http://google.com/", "about"));
163}
164
165TEST(URLUtilTest, DecodeURLEscapeSequences) {
166  struct DecodeCase {
167    const char* input;
168    const char* output;
169  } decode_cases[] = {
170    {"hello, world", "hello, world"},
171    {"%01%02%03%04%05%06%07%08%09%0a%0B%0C%0D%0e%0f/",
172     "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0B\x0C\x0D\x0e\x0f/"},
173    {"%10%11%12%13%14%15%16%17%18%19%1a%1B%1C%1D%1e%1f/",
174     "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1B\x1C\x1D\x1e\x1f/"},
175    {"%20%21%22%23%24%25%26%27%28%29%2a%2B%2C%2D%2e%2f/",
176     " !\"#$%&'()*+,-.//"},
177    {"%30%31%32%33%34%35%36%37%38%39%3a%3B%3C%3D%3e%3f/",
178     "0123456789:;<=>?/"},
179    {"%40%41%42%43%44%45%46%47%48%49%4a%4B%4C%4D%4e%4f/",
180     "@ABCDEFGHIJKLMNO/"},
181    {"%50%51%52%53%54%55%56%57%58%59%5a%5B%5C%5D%5e%5f/",
182     "PQRSTUVWXYZ[\\]^_/"},
183    {"%60%61%62%63%64%65%66%67%68%69%6a%6B%6C%6D%6e%6f/",
184     "`abcdefghijklmno/"},
185    {"%70%71%72%73%74%75%76%77%78%79%7a%7B%7C%7D%7e%7f/",
186     "pqrstuvwxyz{|}~\x7f/"},
187    // Test un-UTF-8-ization.
188    {"%e4%bd%a0%e5%a5%bd", "\xe4\xbd\xa0\xe5\xa5\xbd"},
189  };
190
191  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(decode_cases); i++) {
192    const char* input = decode_cases[i].input;
193    url_canon::RawCanonOutputT<char16> output;
194    url_util::DecodeURLEscapeSequences(input, strlen(input), &output);
195    EXPECT_EQ(decode_cases[i].output,
196              url_test_utils::ConvertUTF16ToUTF8(
197                string16(output.data(), output.length())));
198  }
199
200  // Our decode should decode %00
201  const char zero_input[] = "%00";
202  url_canon::RawCanonOutputT<char16> zero_output;
203  url_util::DecodeURLEscapeSequences(zero_input, strlen(zero_input),
204                                     &zero_output);
205  EXPECT_NE("%00",
206            url_test_utils::ConvertUTF16ToUTF8(
207              string16(zero_output.data(), zero_output.length())));
208
209  // Test the error behavior for invalid UTF-8.
210  const char invalid_input[] = "%e4%a0%e5%a5%bd";
211  const char16 invalid_expected[4] = {0x00e4, 0x00a0, 0x597d, 0};
212  url_canon::RawCanonOutputT<char16> invalid_output;
213  url_util::DecodeURLEscapeSequences(invalid_input, strlen(invalid_input),
214                                     &invalid_output);
215  EXPECT_EQ(string16(invalid_expected),
216            string16(invalid_output.data(), invalid_output.length()));
217}
218
219