Fix various problems with inline autocomplete and URLs that change length dur...

net/base/escape_unittest.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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 <string>
 
 #include "net/base/escape.h"
 
 #include "base/basictypes.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 struct EscapeCase {
   const wchar_t* input;
   const wchar_t* output;
 };
 
 struct UnescapeURLCase {
   const char* input;
   UnescapeRule::Type rules;
   const char* output;
 };
 
-struct UnescapeAndDecodeURLCase {
-  const char* encoding;
+struct UnescapeAndDecodeCase {
   const char* input;
 
   // The expected output when run through UnescapeURL.
   const char* url_unescaped;
 
   // The expected output when run through UnescapeQuery.
   const char* query_unescaped;
 
   // The expected output when run through UnescapeAndDecodeURLComponent.
   const wchar_t* decoded;
 };
 
+struct AdjustOffsetCase {
+  const char* input;
+  size_t input_offset;
+  size_t output_offset;
+};
+
 struct EscapeForHTMLCase {
   const char* input;
   const char* expected_output;
 };
 
 }  // namespace
 
-TEST(Escape, EscapeTextForFormSubmission) {
+TEST(EscapeTest, EscapeTextForFormSubmission) {
   const EscapeCase escape_cases[] = {
     {L"foo", L"foo"},
     {L"foo bar", L"foo+bar"},
     {L"foo++", L"foo%2B%2B"}
   };
   for (size_t i = 0; i < arraysize(escape_cases); ++i) {
     EscapeCase value = escape_cases[i];
     EXPECT_EQ(value.output, EscapeQueryParamValueUTF8(value.input));
   }
 
@@ skipping 27 matching lines @@
   std::wstring test_str;
   test_str.reserve(5000);
   for (int i = 1; i < 5000; ++i) {
     test_str.push_back(i);
   }
   std::wstring wide;
   EXPECT_TRUE(EscapeQueryParamValue(test_str, base::kCodepageUTF8, &wide));
   EXPECT_EQ(wide, EscapeQueryParamValueUTF8(test_str));
 }
 
-TEST(Escape, EscapePath) {
+TEST(EscapeTest, EscapePath) {
   ASSERT_EQ(
     // Most of the character space we care about, un-escaped
     EscapePath(
       "\x02\n\x1d !\"#$%&'()*+,-./0123456789:;"
       "<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
       "[\\]^_`abcdefghijklmnopqrstuvwxyz"
       "{|}~\x7f\x80\xff"),
     // Escaped
     "%02%0A%1D%20!%22%23$%25&'()*+,-./0123456789%3A;"
     "%3C=%3E%3F@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     "%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz"
     "%7B%7C%7D~%7F%80%FF");
 }
 
-TEST(Escape, EscapeUrlEncodedData) {
+TEST(EscapeTest, EscapeUrlEncodedData) {
   ASSERT_EQ(
     // Most of the character space we care about, un-escaped
     EscapeUrlEncodedData(
       "\x02\n\x1d !\"#$%&'()*+,-./0123456789:;"
       "<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
       "[\\]^_`abcdefghijklmnopqrstuvwxyz"
       "{|}~\x7f\x80\xff"),
     // Escaped
     "%02%0A%1D+!%22%23%24%25%26%27()*%2B,-./0123456789:%3B"
     "%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     "%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz"
     "%7B%7C%7D~%7F%80%FF");
 }
 
-TEST(Escape, UnescapeURLComponent) {
+TEST(EscapeTest, UnescapeURLComponent) {
   const UnescapeURLCase unescape_cases[] = {
     {"", UnescapeRule::NORMAL, ""},
     {"%2", UnescapeRule::NORMAL, "%2"},
     {"%%%%%%", UnescapeRule::NORMAL, "%%%%%%"},
     {"Don't escape anything", UnescapeRule::NORMAL, "Don't escape anything"},
     {"Invalid %escape %2", UnescapeRule::NORMAL, "Invalid %escape %2"},
     {"Some%20random text %25%3bOK", UnescapeRule::NONE,
      "Some%20random text %25%3bOK"},
     {"Some%20random text %25%3bOK", UnescapeRule::NORMAL,
      "Some%20random text %25;OK"},
@@ skipping 40 matching lines @@
   expected.append("9Test");
   EXPECT_EQ(expected, UnescapeURLComponent(input, UnescapeRule::CONTROL_CHARS));
 
   // When we're not unescaping NULLs.
   expected = "Null";
   expected.push_back(0);
   expected.append("%009Test");
   EXPECT_EQ(expected, UnescapeURLComponent(input, UnescapeRule::NORMAL));
 }
 
-TEST(Escape, UnescapeAndDecodeURLComponent) {
-  const UnescapeAndDecodeURLCase unescape_cases[] = {
-    {"UTF8", "%", "%", "%", L"%"},
-    {"UTF8", "+", "+", " ", L"+"},
-    {"UTF8", "%2+", "%2+", "%2 ", L"%2+"},
-    {"UTF8", "+%%%+%%%", "+%%%+%%%", " %%% %%%", L"+%%%+%%%"},
-    {"UTF8", "Don't escape anything",
-             "Don't escape anything",
-             "Don't escape anything",
-             L"Don't escape anything"},
-    {"UTF8", "+Invalid %escape %2+",
-             "+Invalid %escape %2+",
-             " Invalid %escape %2 ",
-             L"+Invalid %escape %2+"},
-    {"UTF8", "Some random text %25%3bOK",
-             "Some random text %25;OK",
-             "Some random text %25;OK",
-             L"Some random text %25;OK"},
-    {"UTF8", "%01%02%03%04%05%06%07%08%09",
-             "%01%02%03%04%05%06%07%08%09",
-             "%01%02%03%04%05%06%07%08%09",
-             L"%01%02%03%04%05%06%07%08%09"},
-    {"UTF8", "%E4%BD%A0+%E5%A5%BD",
-             "\xE4\xBD\xA0+\xE5\xA5\xBD",
-             "\xE4\xBD\xA0 \xE5\xA5\xBD",
-             L"\x4f60+\x597d"},
-    {"BIG5", "%A7A%A6n",
-             "\xA7\x41\xA6n",
-             "\xA7\x41\xA6n",
-             L"\x4f60\x597d"},
-    {"UTF8", "%ED%ED",  // Invalid UTF-8.
-             "\xED\xED",
-             "\xED\xED",
-             L"%ED%ED"},  // Invalid UTF-8 -> kept unescaped.
+TEST(EscapeTest, UnescapeAndDecodeUTF8URLComponent) {
+  const UnescapeAndDecodeCase unescape_cases[] = {
+    { "%",
+      "%",
+      "%",
+     L"%"},
+    { "+",
+      "+",
+      " ",
+     L"+"},
+    { "%2+",
+      "%2+",
+      "%2 ",
+     L"%2+"},
+    { "+%%%+%%%",
+      "+%%%+%%%",
+      " %%% %%%",
+     L"+%%%+%%%"},
+    { "Don't escape anything",
+      "Don't escape anything",
+      "Don't escape anything",
+     L"Don't escape anything"},
+    { "+Invalid %escape %2+",
+      "+Invalid %escape %2+",
+      " Invalid %escape %2 ",
+     L"+Invalid %escape %2+"},
+    { "Some random text %25%3BOK",
+      "Some random text %25;OK",
+      "Some random text %25;OK",
+     L"Some random text %25;OK"},
+    { "%01%02%03%04%05%06%07%08%09",
+      "%01%02%03%04%05%06%07%08%09",
+      "%01%02%03%04%05%06%07%08%09",
+     L"%01%02%03%04%05%06%07%08%09"},
+    { "%E4%BD%A0+%E5%A5%BD",
+      "\xE4\xBD\xA0+\xE5\xA5\xBD",
+      "\xE4\xBD\xA0 \xE5\xA5\xBD",
+     L"\x4f60+\x597d"},
+    { "%ED%ED",  // Invalid UTF-8.
+      "\xED\xED",
+      "\xED\xED",
+     L"%ED%ED"},  // Invalid UTF-8 -> kept unescaped.
   };
 
   for (size_t i = 0; i < arraysize(unescape_cases); i++) {
     std::string unescaped = UnescapeURLComponent(unescape_cases[i].input,
                                                  UnescapeRule::NORMAL);
     EXPECT_EQ(std::string(unescape_cases[i].url_unescaped), unescaped);
 
     unescaped = UnescapeURLComponent(unescape_cases[i].input,
                                      UnescapeRule::REPLACE_PLUS_WITH_SPACE);
     EXPECT_EQ(std::string(unescape_cases[i].query_unescaped), unescaped);
 
     // TODO: Need to test unescape_spaces and unescape_percent.
-    std::wstring decoded = UnescapeAndDecodeURLComponent(
-        unescape_cases[i].input, unescape_cases[i].encoding,
-        UnescapeRule::NORMAL);
+    std::wstring decoded = UnescapeAndDecodeUTF8URLComponent(
+        unescape_cases[i].input, UnescapeRule::NORMAL, NULL);
     EXPECT_EQ(std::wstring(unescape_cases[i].decoded), decoded);
   }
 }
 
-TEST(Escape, EscapeForHTML) {
+TEST(EscapeTest, AdjustOffset) {
+  const AdjustOffsetCase adjust_cases[] = {
+    {"", 0, std::wstring::npos},
+    {"test", 0, 0},
+    {"test", 2, 2},
+    {"test", 4, std::wstring::npos},
+    {"test", std::wstring::npos, std::wstring::npos},
+    {"%3Btest", 6, 4},
+    {"%3Btest", 2, std::wstring::npos},
+    {"test%3B", 2, 2},
+    {"%E4%BD%A0+%E5%A5%BD", 9, 1},
+    {"%E4%BD%A0+%E5%A5%BD", 6, std::wstring::npos},
+    {"%ED%B0%80+%E5%A5%BD", 6, 6},
+  };
+
+  for (size_t i = 0; i < arraysize(adjust_cases); i++) {
+    size_t offset = adjust_cases[i].input_offset;
+    UnescapeAndDecodeUTF8URLComponent(adjust_cases[i].input,
+                                      UnescapeRule::NORMAL, &offset);
+    EXPECT_EQ(adjust_cases[i].output_offset, offset);
+  }
+}
+
+TEST(EscapeTest, EscapeForHTML) {
   const EscapeForHTMLCase tests[] = {
     { "hello", "hello" },
     { "<hello>", "&lt;hello&gt;" },
     { "don\'t mess with me", "don&#39;t mess with me" },
   };
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string result = EscapeForHTML(std::string(tests[i].input));
     EXPECT_EQ(std::string(tests[i].expected_output), result);
   }
 }