Move net::FormatUrl and friends outside of //net and into //components

components/url_formatter/url_formatter_unittest.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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 "net/base/net_util.h"
+#include "components/url_formatter/url_formatter.h"
 
 #include <string.h>
 
 #include <vector>
 
-#include "base/format_macros.h"
-#include "base/strings/string_number_conversions.h"
+#include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
-using base::ASCIIToUTF16;
-using base::WideToUTF16;
 
-namespace net {
+namespace url_formatter {
 
 namespace {
 
+using base::WideToUTF16;
+using base::ASCIIToUTF16;
+
 const size_t kNpos = base::string16::npos;
 
 const char* const kLanguages[] = {
   "",      "en",    "zh-CN",    "ja",    "ko",
   "he",    "ar",    "ru",       "el",    "fr",
   "de",    "pt",    "sv",       "th",    "hi",
   "de,en", "el,en", "zh-TW,en", "ko,ja", "he,ru,en",
   "zh,ru,en"
 };
 
@@ skipping 381 matching lines @@
   for (size_t i = 0; i < url_length; ++i)
     VerboseExpect(output_offsets[i], offsets[i], url_string, i, formatted_url);
   VerboseExpect(formatted_url.length(), offsets[url_length], url_string,
                 url_length, formatted_url);
   VerboseExpect(base::string16::npos, offsets[url_length + 1], url_string,
                 500000, formatted_url);
   VerboseExpect(base::string16::npos, offsets[url_length + 2], url_string,
                 std::string::npos, formatted_url);
 }
 
-}  // anonymous namespace
-
 TEST(NetUtilTest, IDNToUnicodeFast) {
   for (size_t i = 0; i < arraysize(idn_cases); i++) {
     for (size_t j = 0; j < arraysize(kLanguages); j++) {
       // ja || zh-TW,en || ko,ja -> IDNToUnicodeSlow
       if (j == 3 || j == 17 || j == 18)
         continue;
       base::string16 output(IDNToUnicode(idn_cases[i].input, kLanguages[j]));
       base::string16 expected(idn_cases[i].unicode_allowed[j] ?
           WideToUTF16(idn_cases[i].unicode_output) :
           ASCIIToUTF16(idn_cases[i].input));
@@ skipping 35 matching lines @@
   }
 }
 
 TEST(NetUtilTest, StripWWW) {
   EXPECT_EQ(base::string16(), StripWWW(base::string16()));
   EXPECT_EQ(base::string16(), StripWWW(ASCIIToUTF16("www.")));
   EXPECT_EQ(ASCIIToUTF16("blah"), StripWWW(ASCIIToUTF16("www.blah")));
   EXPECT_EQ(ASCIIToUTF16("blah"), StripWWW(ASCIIToUTF16("blah")));
 }
 
-// This is currently a windows specific function.
-#if defined(OS_WIN)
-namespace {
-
-struct GetDirectoryListingEntryCase {
-  const wchar_t* name;
-  const char* const raw_bytes;
-  bool is_dir;
-  int64_t filesize;
-  base::Time time;
-  const char* const expected;
-};
-
-}  // namespace
-
-TEST(NetUtilTest, GetDirectoryListingEntry) {
-  const GetDirectoryListingEntryCase test_cases[] = {
-    {L"Foo",
-     "",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"Foo\",\"Foo\",0,\"9.8 kB\",\"\");</script>\n"},
-    {L"quo\"tes",
-     "",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"quo\\\"tes\",\"quo%22tes\",0,\"9.8 kB\",\"\");</script>"
-         "\n"},
-    {L"quo\"tes",
-     "quo\"tes",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"quo\\\"tes\",\"quo%22tes\",0,\"9.8 kB\",\"\");</script>"
-         "\n"},
-    // U+D55C0 U+AE00. raw_bytes is empty (either a local file with
-    // UTF-8/UTF-16 encoding or a remote file on an ftp server using UTF-8
-    {L"\xD55C\xAE00.txt",
-     "",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"\xED\x95\x9C\xEA\xB8\x80.txt\","
-         "\"%ED%95%9C%EA%B8%80.txt\",0,\"9.8 kB\",\"\");</script>\n"},
-    // U+D55C0 U+AE00. raw_bytes is the corresponding EUC-KR sequence:
-    // a local or remote file in EUC-KR.
-    {L"\xD55C\xAE00.txt",
-     "\xC7\xD1\xB1\xDB.txt",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"\xED\x95\x9C\xEA\xB8\x80.txt\",\"%C7%D1%B1%DB.txt\""
-         ",0,\"9.8 kB\",\"\");</script>\n"},
-  };
-
-  for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    const std::string results = GetDirectoryListingEntry(
-        WideToUTF16(test_cases[i].name),
-        test_cases[i].raw_bytes,
-        test_cases[i].is_dir,
-        test_cases[i].filesize,
-        test_cases[i].time);
-    EXPECT_EQ(test_cases[i].expected, results);
-  }
-}
-
-#endif
-
 TEST(NetUtilTest, FormatUrl) {
   FormatUrlTypes default_format_type = kFormatUrlOmitUsernamePassword;
   const UrlTestData tests[] = {
     {"Empty URL", "", "", default_format_type, UnescapeRule::NORMAL, L"", 0},
 
     {"Simple URL",
      "http://www.google.com/", "", default_format_type, UnescapeRule::NORMAL,
      L"http://www.google.com/", 7},
 
     {"With a port number and a reference",
@@ skipping 529 matching lines @@
                        UnescapeRule::NORMAL, omit_http_start_with_ftp_offsets);
 
   const size_t omit_all_offsets[] = {
     0, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 0, kNpos, kNpos, kNpos, kNpos,
     0, 1, 2, 3, 4, 5, 6, 7
   };
   CheckAdjustedOffsets("http://user@foo.com/", "en", kFormatUrlOmitAll,
                        UnescapeRule::NORMAL, omit_all_offsets);
 }
 
-}  // namespace net
+}  // namespace
+
+}  // namespace url_formatter