Home | History | Annotate | Download | only in src 
      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 
     37 TEST(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 
     86 TEST(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 
    116 static 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 
    138 TEST(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 
    165 TEST(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