summaryrefslogtreecommitdiffstats
path: root/net/base/net_util_unittest.cc
diff options
context:
space:
mode:
Diffstat (limited to 'net/base/net_util_unittest.cc')
-rw-r--r--net/base/net_util_unittest.cc269
1 files changed, 135 insertions, 134 deletions
diff --git a/net/base/net_util_unittest.cc b/net/base/net_util_unittest.cc
index 8f05c20..9f15bc5 100644
--- a/net/base/net_util_unittest.cc
+++ b/net/base/net_util_unittest.cc
@@ -17,10 +17,9 @@
#include "net/base/sys_addrinfo.h"
#include "testing/gtest/include/gtest/gtest.h"
-namespace {
+namespace net {
-class NetUtilTest : public testing::Test {
-};
+namespace {
struct FileCase {
const wchar_t* file;
@@ -391,7 +390,7 @@ struct UrlTestData {
const char* description;
const char* input;
const char* languages;
- net::FormatUrlTypes format_types;
+ FormatUrlTypes format_types;
UnescapeRule::Type escape_rules;
const wchar_t* output; // Use |wchar_t| to handle Unicode constants easily.
size_t prefix_len;
@@ -458,7 +457,7 @@ void AppendLanguagesToOutputs(const wchar_t* languages,
}
// Helper to strignize an IP number (used to define expectations).
-std::string DumpIPNumber(const net::IPAddressNumber& v) {
+std::string DumpIPNumber(const IPAddressNumber& v) {
std::string out;
for (size_t i = 0; i < v.size(); ++i) {
if (i != 0)
@@ -512,12 +511,12 @@ TEST(NetUtilTest, FileURLConversion) {
FilePath output;
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(round_trip_cases); i++) {
// convert to the file URL
- GURL file_url(net::FilePathToFileURL(
+ GURL file_url(FilePathToFileURL(
file_util::WStringAsFilePath(round_trip_cases[i].file)));
EXPECT_EQ(round_trip_cases[i].url, file_url.spec());
// Back to the filename.
- EXPECT_TRUE(net::FileURLToFilePath(file_url, &output));
+ EXPECT_TRUE(FileURLToFilePath(file_url, &output));
EXPECT_EQ(round_trip_cases[i].file, file_util::FilePathAsWString(output));
}
@@ -556,7 +555,7 @@ TEST(NetUtilTest, FileURLConversion) {
#endif
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(url_cases); i++) {
- net::FileURLToFilePath(GURL(url_cases[i].url), &output);
+ FileURLToFilePath(GURL(url_cases[i].url), &output);
EXPECT_EQ(url_cases[i].file, file_util::FilePathAsWString(output));
}
@@ -566,13 +565,13 @@ TEST(NetUtilTest, FileURLConversion) {
// the input is preserved in UTF-8
const char invalid_utf8[] = "file:///d:/Blah/\xff.doc";
const wchar_t invalid_wide[] = L"D:\\Blah\\\xff.doc";
- EXPECT_TRUE(net::FileURLToFilePath(
+ EXPECT_TRUE(FileURLToFilePath(
GURL(std::string(invalid_utf8)), &output));
EXPECT_EQ(std::wstring(invalid_wide), output);
#endif
// Test that if a file URL is malformed, we get a failure
- EXPECT_FALSE(net::FileURLToFilePath(GURL("filefoobar"), &output));
+ EXPECT_FALSE(FileURLToFilePath(GURL("filefoobar"), &output));
}
TEST(NetUtilTest, GetIdentityFromURL) {
@@ -623,7 +622,7 @@ TEST(NetUtilTest, GetIdentityFromURL) {
GURL url(tests[i].input_url);
string16 username, password;
- net::GetIdentityFromURL(url, &username, &password);
+ GetIdentityFromURL(url, &username, &password);
EXPECT_EQ(ASCIIToUTF16(tests[i].expected_username), username);
EXPECT_EQ(ASCIIToUTF16(tests[i].expected_password), password);
@@ -639,7 +638,7 @@ TEST(NetUtilTest, GetIdentityFromURL_UTF8) {
// Extract the unescaped identity.
string16 username, password;
- net::GetIdentityFromURL(url, &username, &password);
+ GetIdentityFromURL(url, &username, &password);
// Verify that it was decoded as UTF8.
EXPECT_EQ(ASCIIToUTF16("foo"), username);
@@ -680,14 +679,14 @@ TEST(NetUtilTest, GetSpecificHeader) {
// Test first with google_headers.
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
- std::wstring result = net::GetSpecificHeader(google_headers,
+ std::wstring result = GetSpecificHeader(google_headers,
tests[i].header_name);
EXPECT_EQ(result, tests[i].expected);
}
// Test again with empty headers.
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
- std::wstring result = net::GetSpecificHeader(L"", tests[i].header_name);
+ std::wstring result = GetSpecificHeader(L"", tests[i].header_name);
EXPECT_EQ(result, std::wstring());
}
}
@@ -710,19 +709,19 @@ TEST(NetUtilTest, GetHeaderParamValue) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
std::wstring header_value =
- net::GetSpecificHeader(google_headers, tests[i].header_name);
+ GetSpecificHeader(google_headers, tests[i].header_name);
std::wstring result =
- net::GetHeaderParamValue(header_value, tests[i].param_name,
- net::QuoteRule::REMOVE_OUTER_QUOTES);
+ GetHeaderParamValue(header_value, tests[i].param_name,
+ QuoteRule::REMOVE_OUTER_QUOTES);
EXPECT_EQ(result, tests[i].expected);
}
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
std::wstring header_value =
- net::GetSpecificHeader(L"", tests[i].header_name);
+ GetSpecificHeader(L"", tests[i].header_name);
std::wstring result =
- net::GetHeaderParamValue(header_value, tests[i].param_name,
- net::QuoteRule::REMOVE_OUTER_QUOTES);
+ GetHeaderParamValue(header_value, tests[i].param_name,
+ QuoteRule::REMOVE_OUTER_QUOTES);
EXPECT_EQ(result, std::wstring());
}
}
@@ -741,11 +740,11 @@ TEST(NetUtilTest, GetHeaderParamValueQuotes) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
std::string actual_with_quotes =
- net::GetHeaderParamValue(tests[i].header, "filename",
- net::QuoteRule::KEEP_OUTER_QUOTES);
+ GetHeaderParamValue(tests[i].header, "filename",
+ QuoteRule::KEEP_OUTER_QUOTES);
std::string actual_without_quotes =
- net::GetHeaderParamValue(tests[i].header, "filename",
- net::QuoteRule::REMOVE_OUTER_QUOTES);
+ GetHeaderParamValue(tests[i].header, "filename",
+ QuoteRule::REMOVE_OUTER_QUOTES);
EXPECT_EQ(tests[i].expected_with_quotes, actual_with_quotes)
<< "Failed while processing: " << tests[i].header;
EXPECT_EQ(tests[i].expected_without_quotes, actual_without_quotes)
@@ -924,8 +923,8 @@ TEST(NetUtilTest, GetFileNameFromCD) {
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
EXPECT_EQ(tests[i].expected,
- UTF8ToWide(net::GetFileNameFromCD(tests[i].header_field,
- tests[i].referrer_charset)))
+ UTF8ToWide(GetFileNameFromCD(tests[i].header_field,
+ tests[i].referrer_charset)))
<< "Failed on input: " << tests[i].header_field;
}
}
@@ -936,7 +935,7 @@ TEST(NetUtilTest, IDNToUnicodeFast) {
// ja || zh-TW,en || ko,ja -> IDNToUnicodeSlow
if (j == 3 || j == 17 || j == 18)
continue;
- std::wstring output(net::IDNToUnicode(idn_cases[i].input,
+ std::wstring output(IDNToUnicode(idn_cases[i].input,
strlen(idn_cases[i].input), kLanguages[j], NULL));
std::wstring expected(idn_cases[i].unicode_allowed[j] ?
idn_cases[i].unicode_output : ASCIIToWide(idn_cases[i].input));
@@ -952,7 +951,7 @@ TEST(NetUtilTest, IDNToUnicodeSlow) {
// !(ja || zh-TW,en || ko,ja) -> IDNToUnicodeFast
if (!(j == 3 || j == 17 || j == 18))
continue;
- std::wstring output(net::IDNToUnicode(idn_cases[i].input,
+ std::wstring output(IDNToUnicode(idn_cases[i].input,
strlen(idn_cases[i].input), kLanguages[j], NULL));
std::wstring expected(idn_cases[i].unicode_allowed[j] ?
idn_cases[i].unicode_output : ASCIIToWide(idn_cases[i].input));
@@ -983,7 +982,7 @@ TEST(NetUtilTest, IDNToUnicodeAdjustOffset) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(adjust_cases); ++i) {
size_t offset = adjust_cases[i].input_offset;
// "test.\x89c6\x9891.\x5317\x4eac\x5927\x5b78.test"
- net::IDNToUnicode("test.xn--cy2a840a.xn--1lq90ic7f1rc.test", 39, L"zh-CN",
+ IDNToUnicode("test.xn--cy2a840a.xn--1lq90ic7f1rc.test", 39, L"zh-CN",
&offset);
EXPECT_EQ(adjust_cases[i].output_offset, offset);
}
@@ -1018,16 +1017,16 @@ TEST(NetUtilTest, CompliantHost) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(compliant_host_cases); ++i) {
EXPECT_EQ(compliant_host_cases[i].expected_output,
- net::IsCanonicalizedHostCompliant(compliant_host_cases[i].host,
+ IsCanonicalizedHostCompliant(compliant_host_cases[i].host,
compliant_host_cases[i].desired_tld));
}
}
TEST(NetUtilTest, StripWWW) {
- EXPECT_EQ(string16(), net::StripWWW(string16()));
- EXPECT_EQ(string16(), net::StripWWW(ASCIIToUTF16("www.")));
- EXPECT_EQ(ASCIIToUTF16("blah"), net::StripWWW(ASCIIToUTF16("www.blah")));
- EXPECT_EQ(ASCIIToUTF16("blah"), net::StripWWW(ASCIIToUTF16("blah")));
+ EXPECT_EQ(string16(), StripWWW(string16()));
+ EXPECT_EQ(string16(), StripWWW(ASCIIToUTF16("www.")));
+ EXPECT_EQ(ASCIIToUTF16("blah"), StripWWW(ASCIIToUTF16("www.blah")));
+ EXPECT_EQ(ASCIIToUTF16("blah"), StripWWW(ASCIIToUTF16("blah")));
}
TEST(NetUtilTest, GetSuggestedFilename) {
@@ -1221,7 +1220,7 @@ TEST(NetUtilTest, GetSuggestedFilename) {
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
std::wstring default_name = test_cases[i].default_filename;
- string16 filename = net::GetSuggestedFilename(
+ string16 filename = GetSuggestedFilename(
GURL(test_cases[i].url), test_cases[i].content_disp_header,
test_cases[i].referrer_charset, WideToUTF16(default_name));
EXPECT_EQ(std::wstring(test_cases[i].expected_filename),
@@ -1287,7 +1286,7 @@ TEST(NetUtilTest, GetDirectoryListingEntry) {
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
- const std::string results = net::GetDirectoryListingEntry(
+ const std::string results = GetDirectoryListingEntry(
WideToUTF16(test_cases[i].name),
test_cases[i].raw_bytes,
test_cases[i].is_dir,
@@ -1333,7 +1332,7 @@ TEST(NetUtilTest, ParseHostAndPort) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
std::string host;
int port;
- bool ok = net::ParseHostAndPort(tests[i].input, &host, &port);
+ bool ok = ParseHostAndPort(tests[i].input, &host, &port);
EXPECT_EQ(tests[i].success, ok);
@@ -1357,7 +1356,7 @@ TEST(NetUtilTest, GetHostAndPort) {
{ GURL("http://[::a]:33/x"), "[::a]:33"},
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
- std::string host_and_port = net::GetHostAndPort(tests[i].url);
+ std::string host_and_port = GetHostAndPort(tests[i].url);
EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
}
}
@@ -1375,7 +1374,7 @@ TEST(NetUtilTest, GetHostAndOptionalPort) {
{ GURL("http://[::a]:33/x"), "[::a]:33"},
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
- std::string host_and_port = net::GetHostAndOptionalPort(tests[i].url);
+ std::string host_and_port = GetHostAndOptionalPort(tests[i].url);
EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
}
}
@@ -1393,7 +1392,7 @@ TEST(NetUtilTest, NetAddressToString_IPv4) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
const addrinfo* ai = GetIPv4Address(tests[i].addr, 80);
- std::string result = net::NetAddressToString(ai);
+ std::string result = NetAddressToString(ai);
EXPECT_EQ(std::string(tests[i].result), result);
}
}
@@ -1410,7 +1409,7 @@ TEST(NetUtilTest, NetAddressToString_IPv6) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
const addrinfo* ai = GetIPv6Address(tests[i].addr, 80);
- std::string result = net::NetAddressToString(ai);
+ std::string result = NetAddressToString(ai);
// Allow NetAddressToString() to fail, in case the system doesn't
// support IPv6.
if (!result.empty())
@@ -1421,7 +1420,7 @@ TEST(NetUtilTest, NetAddressToString_IPv6) {
TEST(NetUtilTest, NetAddressToStringWithPort_IPv4) {
uint8 addr[] = {127, 0, 0, 1};
const addrinfo* ai = GetIPv4Address(addr, 166);
- std::string result = net::NetAddressToStringWithPort(ai);
+ std::string result = NetAddressToStringWithPort(ai);
EXPECT_EQ("127.0.0.1:166", result);
}
@@ -1431,7 +1430,7 @@ TEST(NetUtilTest, NetAddressToStringWithPort_IPv6) {
0x98, 0x76, 0x54, 0x32, 0x10
};
const addrinfo* ai = GetIPv6Address(addr, 361);
- std::string result = net::NetAddressToStringWithPort(ai);
+ std::string result = NetAddressToStringWithPort(ai);
// May fail on systems that don't support IPv6.
if (!result.empty())
@@ -1442,12 +1441,12 @@ TEST(NetUtilTest, GetHostName) {
// We can't check the result of GetHostName() directly, since the result
// will differ across machines. Our goal here is to simply exercise the
// code path, and check that things "look about right".
- std::string hostname = net::GetHostName();
+ std::string hostname = GetHostName();
EXPECT_FALSE(hostname.empty());
}
TEST(NetUtilTest, FormatUrl) {
- net::FormatUrlTypes default_format_type = net::kFormatUrlOmitUsernamePassword;
+ FormatUrlTypes default_format_type = kFormatUrlOmitUsernamePassword;
const UrlTestData tests[] = {
{"Empty URL", "", "", default_format_type, UnescapeRule::NORMAL, L"", 0},
@@ -1494,7 +1493,7 @@ TEST(NetUtilTest, FormatUrl) {
// -------- omit_username_password flag tests --------
{"With username and password, omit_username_password=false",
"http://user:passwd@example.com/foo", "",
- net::kFormatUrlOmitNothing, UnescapeRule::NORMAL,
+ kFormatUrlOmitNothing, UnescapeRule::NORMAL,
L"http://user:passwd@example.com/foo", 19},
{"With username and password, omit_username_password=true",
@@ -1539,53 +1538,53 @@ TEST(NetUtilTest, FormatUrl) {
/*
{"unescape=true with some special characters",
"http://user%3A:%40passwd@example.com/foo%3Fbar?q=b%26z", "",
- net::kFormatUrlOmitNothing, UnescapeRule::NORMAL,
+ kFormatUrlOmitNothing, UnescapeRule::NORMAL,
L"http://user%3A:%40passwd@example.com/foo%3Fbar?q=b%26z", 25},
*/
// Disabled: the resultant URL becomes "...user%253A:%2540passwd...".
// -------- omit http: --------
{"omit http with user name",
- "http://user@example.com/foo", "", net::kFormatUrlOmitAll,
+ "http://user@example.com/foo", "", kFormatUrlOmitAll,
UnescapeRule::NORMAL, L"example.com/foo", 0},
{"omit http",
- "http://www.google.com/", "en", net::kFormatUrlOmitHTTP,
+ "http://www.google.com/", "en", kFormatUrlOmitHTTP,
UnescapeRule::NORMAL, L"www.google.com/",
0},
{"omit http with https",
- "https://www.google.com/", "en", net::kFormatUrlOmitHTTP,
+ "https://www.google.com/", "en", kFormatUrlOmitHTTP,
UnescapeRule::NORMAL, L"https://www.google.com/",
8},
{"omit http starts with ftp.",
- "http://ftp.google.com/", "en", net::kFormatUrlOmitHTTP,
+ "http://ftp.google.com/", "en", kFormatUrlOmitHTTP,
UnescapeRule::NORMAL, L"http://ftp.google.com/",
7},
// -------- omit trailing slash on bare hostname --------
{"omit slash when it's the entire path",
"http://www.google.com/", "en",
- net::kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
+ kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
L"http://www.google.com", 7},
{"omit slash when there's a ref",
"http://www.google.com/#ref", "en",
- net::kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
+ kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
L"http://www.google.com/#ref", 7},
{"omit slash when there's a query",
"http://www.google.com/?", "en",
- net::kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
+ kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
L"http://www.google.com/?", 7},
{"omit slash when it's not the entire path",
"http://www.google.com/foo", "en",
- net::kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
+ kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
L"http://www.google.com/foo", 7},
{"omit slash for nonstandard URLs",
- "data:/", "en", net::kFormatUrlOmitTrailingSlashOnBareHostname,
+ "data:/", "en", kFormatUrlOmitTrailingSlashOnBareHostname,
UnescapeRule::NORMAL, L"data:/", 5},
{"omit slash for file URLs",
- "file:///", "en", net::kFormatUrlOmitTrailingSlashOnBareHostname,
+ "file:///", "en", kFormatUrlOmitTrailingSlashOnBareHostname,
UnescapeRule::NORMAL, L"file:///", 7},
// -------- view-source: --------
@@ -1602,22 +1601,22 @@ TEST(NetUtilTest, FormatUrl) {
// view-source should omit http and trailing slash where non-view-source
// would.
{"view-source omit http",
- "view-source:http://a.b/c", "en", net::kFormatUrlOmitAll,
+ "view-source:http://a.b/c", "en", kFormatUrlOmitAll,
UnescapeRule::NORMAL, L"view-source:a.b/c",
12},
{"view-source omit http starts with ftp.",
- "view-source:http://ftp.b/c", "en", net::kFormatUrlOmitAll,
+ "view-source:http://ftp.b/c", "en", kFormatUrlOmitAll,
UnescapeRule::NORMAL, L"view-source:http://ftp.b/c",
19},
{"view-source omit slash when it's the entire path",
- "view-source:http://a.b/", "en", net::kFormatUrlOmitAll,
+ "view-source:http://a.b/", "en", kFormatUrlOmitAll,
UnescapeRule::NORMAL, L"view-source:a.b",
12},
};
for (size_t i = 0; i < arraysize(tests); ++i) {
size_t prefix_len;
- string16 formatted = net::FormatUrl(
+ string16 formatted = FormatUrl(
GURL(tests[i].input), tests[i].languages, tests[i].format_types,
tests[i].escape_rules, NULL, &prefix_len, NULL);
EXPECT_EQ(WideToUTF16(tests[i].output), formatted) << tests[i].description;
@@ -1628,10 +1627,10 @@ TEST(NetUtilTest, FormatUrl) {
TEST(NetUtilTest, FormatUrlParsed) {
// No unescape case.
url_parse::Parsed parsed;
- string16 formatted = net::FormatUrl(
+ string16 formatted = FormatUrl(
GURL("http://\xE3\x82\xB0:\xE3\x83\xBC@xn--qcka1pmc.jp:8080/"
"%E3%82%B0/?q=%E3%82%B0#\xE3\x82\xB0"),
- "ja", net::kFormatUrlOmitNothing, UnescapeRule::NONE, &parsed, NULL,
+ "ja", kFormatUrlOmitNothing, UnescapeRule::NONE, &parsed, NULL,
NULL);
EXPECT_EQ(WideToUTF16(
L"http://%E3%82%B0:%E3%83%BC@\x30B0\x30FC\x30B0\x30EB.jp:8080"
@@ -1652,10 +1651,10 @@ TEST(NetUtilTest, FormatUrlParsed) {
formatted.substr(parsed.ref.begin, parsed.ref.len));
// Unescape case.
- formatted = net::FormatUrl(
+ formatted = FormatUrl(
GURL("http://\xE3\x82\xB0:\xE3\x83\xBC@xn--qcka1pmc.jp:8080/"
"%E3%82%B0/?q=%E3%82%B0#\xE3\x82\xB0"),
- "ja", net::kFormatUrlOmitNothing, UnescapeRule::NORMAL, &parsed, NULL,
+ "ja", kFormatUrlOmitNothing, UnescapeRule::NORMAL, &parsed, NULL,
NULL);
EXPECT_EQ(WideToUTF16(L"http://\x30B0:\x30FC@\x30B0\x30FC\x30B0\x30EB.jp:8080"
L"/\x30B0/?q=\x30B0#\x30B0"), formatted);
@@ -1675,10 +1674,10 @@ TEST(NetUtilTest, FormatUrlParsed) {
formatted.substr(parsed.ref.begin, parsed.ref.len));
// Omit_username_password + unescape case.
- formatted = net::FormatUrl(
+ formatted = FormatUrl(
GURL("http://\xE3\x82\xB0:\xE3\x83\xBC@xn--qcka1pmc.jp:8080/"
"%E3%82%B0/?q=%E3%82%B0#\xE3\x82\xB0"),
- "ja", net::kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, &parsed,
+ "ja", kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, &parsed,
NULL, NULL);
EXPECT_EQ(WideToUTF16(L"http://\x30B0\x30FC\x30B0\x30EB.jp:8080"
L"/\x30B0/?q=\x30B0#\x30B0"), formatted);
@@ -1696,9 +1695,9 @@ TEST(NetUtilTest, FormatUrlParsed) {
formatted.substr(parsed.ref.begin, parsed.ref.len));
// View-source case.
- formatted = net::FormatUrl(
+ formatted = FormatUrl(
GURL("view-source:http://user:passwd@host:81/path?query#ref"),
- "", net::kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, &parsed,
+ "", kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, &parsed,
NULL, NULL);
EXPECT_EQ(WideToUTF16(L"view-source:http://host:81/path?query#ref"),
formatted);
@@ -1718,9 +1717,9 @@ TEST(NetUtilTest, FormatUrlParsed) {
formatted.substr(parsed.ref.begin, parsed.ref.len));
// omit http case.
- formatted = net::FormatUrl(
+ formatted = FormatUrl(
GURL("http://host:8000/a?b=c#d"),
- "", net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL);
+ "", kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL);
EXPECT_EQ(WideToUTF16(L"host:8000/a?b=c#d"), formatted);
EXPECT_FALSE(parsed.scheme.is_valid());
EXPECT_FALSE(parsed.username.is_valid());
@@ -1737,9 +1736,9 @@ TEST(NetUtilTest, FormatUrlParsed) {
formatted.substr(parsed.ref.begin, parsed.ref.len));
// omit http starts with ftp case.
- formatted = net::FormatUrl(
+ formatted = FormatUrl(
GURL("http://ftp.host:8000/a?b=c#d"),
- "", net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL);
+ "", kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL);
EXPECT_EQ(WideToUTF16(L"http://ftp.host:8000/a?b=c#d"), formatted);
EXPECT_TRUE(parsed.scheme.is_valid());
EXPECT_FALSE(parsed.username.is_valid());
@@ -1758,9 +1757,9 @@ TEST(NetUtilTest, FormatUrlParsed) {
formatted.substr(parsed.ref.begin, parsed.ref.len));
// omit http starts with 'f' case.
- formatted = net::FormatUrl(
+ formatted = FormatUrl(
GURL("http://f/"),
- "", net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL);
+ "", kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL);
EXPECT_EQ(WideToUTF16(L"f/"), formatted);
EXPECT_FALSE(parsed.scheme.is_valid());
EXPECT_FALSE(parsed.username.is_valid());
@@ -1792,8 +1791,8 @@ TEST(NetUtilTest, FormatUrlAdjustOffset) {
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(basic_cases); ++i) {
size_t offset = basic_cases[i].input_offset;
- net::FormatUrl(GURL("http://www.google.com/foo/"), "en",
- net::kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
+ FormatUrl(GURL("http://www.google.com/foo/"), "en",
+ kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
NULL, NULL, &offset);
EXPECT_EQ(basic_cases[i].output_offset, offset);
}
@@ -1816,8 +1815,8 @@ TEST(NetUtilTest, FormatUrlAdjustOffset) {
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(omit_auth_cases); ++i) {
size_t offset = omit_auth_cases[i].input_offset;
- net::FormatUrl(GURL(omit_auth_cases[i].input_url), "en",
- net::kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
+ FormatUrl(GURL(omit_auth_cases[i].input_url), "en",
+ kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
NULL, NULL, &offset);
EXPECT_EQ(omit_auth_cases[i].output_offset, offset);
}
@@ -1836,8 +1835,8 @@ TEST(NetUtilTest, FormatUrlAdjustOffset) {
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(view_source_cases); ++i) {
size_t offset = view_source_cases[i].input_offset;
- net::FormatUrl(GURL("view-source:http://foo@www.google.com/"), "en",
- net::kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
+ FormatUrl(GURL("view-source:http://foo@www.google.com/"), "en",
+ kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
NULL, NULL, &offset);
EXPECT_EQ(view_source_cases[i].output_offset, offset);
}
@@ -1852,8 +1851,8 @@ TEST(NetUtilTest, FormatUrlAdjustOffset) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(idn_hostname_cases); ++i) {
size_t offset = idn_hostname_cases[i].input_offset;
// "http://\x671d\x65e5\x3042\x3055\x3072.jp/foo/"
- net::FormatUrl(GURL("http://xn--l8jvb1ey91xtjb.jp/foo/"), "ja",
- net::kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
+ FormatUrl(GURL("http://xn--l8jvb1ey91xtjb.jp/foo/"), "ja",
+ kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
NULL, NULL, &offset);
EXPECT_EQ(idn_hostname_cases[i].output_offset, offset);
}
@@ -1873,9 +1872,9 @@ TEST(NetUtilTest, FormatUrlAdjustOffset) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(unescape_cases); ++i) {
size_t offset = unescape_cases[i].input_offset;
// "http://www.google.com/foo bar/\x30B0\x30FC\x30B0\x30EB"
- net::FormatUrl(GURL(
+ FormatUrl(GURL(
"http://www.google.com/foo%20bar/%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"),
- "en", net::kFormatUrlOmitUsernamePassword, UnescapeRule::SPACES, NULL,
+ "en", kFormatUrlOmitUsernamePassword, UnescapeRule::SPACES, NULL,
NULL, &offset);
EXPECT_EQ(unescape_cases[i].output_offset, offset);
}
@@ -1891,9 +1890,9 @@ TEST(NetUtilTest, FormatUrlAdjustOffset) {
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(ref_cases); ++i) {
size_t offset = ref_cases[i].input_offset;
// "http://www.google.com/foo.html#\x30B0\x30B0z"
- net::FormatUrl(GURL(
+ FormatUrl(GURL(
"http://www.google.com/foo.html#\xE3\x82\xB0\xE3\x82\xB0z"), "en",
- net::kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, NULL, NULL,
+ kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, NULL, NULL,
&offset);
EXPECT_EQ(ref_cases[i].output_offset, offset);
}
@@ -1906,8 +1905,8 @@ TEST(NetUtilTest, FormatUrlAdjustOffset) {
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(omit_http_cases); ++i) {
size_t offset = omit_http_cases[i].input_offset;
- net::FormatUrl(GURL("http://www.google.com"), "en",
- net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, NULL, NULL, &offset);
+ FormatUrl(GURL("http://www.google.com"), "en",
+ kFormatUrlOmitHTTP, UnescapeRule::NORMAL, NULL, NULL, &offset);
EXPECT_EQ(omit_http_cases[i].output_offset, offset);
}
@@ -1918,8 +1917,8 @@ TEST(NetUtilTest, FormatUrlAdjustOffset) {
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(omit_http_start_with_ftp); ++i) {
size_t offset = omit_http_start_with_ftp[i].input_offset;
- net::FormatUrl(GURL("http://ftp.google.com"), "en",
- net::kFormatUrlOmitHTTP, UnescapeRule::NORMAL, NULL, NULL, &offset);
+ FormatUrl(GURL("http://ftp.google.com"), "en",
+ kFormatUrlOmitHTTP, UnescapeRule::NORMAL, NULL, NULL, &offset);
EXPECT_EQ(omit_http_start_with_ftp[i].output_offset, offset);
}
@@ -1931,7 +1930,7 @@ TEST(NetUtilTest, FormatUrlAdjustOffset) {
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(omit_all_cases); ++i) {
size_t offset = omit_all_cases[i].input_offset;
- net::FormatUrl(GURL("http://user@foo.com/"), "en", net::kFormatUrlOmitAll,
+ FormatUrl(GURL("http://user@foo.com/"), "en", kFormatUrlOmitAll,
UnescapeRule::NORMAL, NULL, NULL, &offset);
EXPECT_EQ(omit_all_cases[i].output_offset, offset);
}
@@ -1978,7 +1977,7 @@ TEST(NetUtilTest, SimplifyUrlForRequest) {
tests[i].input_url));
GURL input_url(GURL(tests[i].input_url));
GURL expected_url(GURL(tests[i].expected_simplified_url));
- EXPECT_EQ(expected_url, net::SimplifyUrlForRequest(input_url));
+ EXPECT_EQ(expected_url, SimplifyUrlForRequest(input_url));
}
}
@@ -1987,58 +1986,58 @@ TEST(NetUtilTest, SetExplicitlyAllowedPortsTest) {
std::string valid[] = { "", "1", "1,2", "1,2,3", "10,11,12,13" };
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(invalid); ++i) {
- net::SetExplicitlyAllowedPorts(invalid[i]);
- EXPECT_EQ(0, static_cast<int>(net::explicitly_allowed_ports.size()));
+ SetExplicitlyAllowedPorts(invalid[i]);
+ EXPECT_EQ(0, static_cast<int>(explicitly_allowed_ports.size()));
}
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(valid); ++i) {
- net::SetExplicitlyAllowedPorts(valid[i]);
- EXPECT_EQ(i, net::explicitly_allowed_ports.size());
+ SetExplicitlyAllowedPorts(valid[i]);
+ EXPECT_EQ(i, explicitly_allowed_ports.size());
}
}
TEST(NetUtilTest, GetHostOrSpecFromURL) {
EXPECT_EQ("example.com",
- net::GetHostOrSpecFromURL(GURL("http://example.com/test")));
+ GetHostOrSpecFromURL(GURL("http://example.com/test")));
EXPECT_EQ("example.com",
- net::GetHostOrSpecFromURL(GURL("http://example.com./test")));
+ GetHostOrSpecFromURL(GURL("http://example.com./test")));
EXPECT_EQ("file:///tmp/test.html",
- net::GetHostOrSpecFromURL(GURL("file:///tmp/test.html")));
+ GetHostOrSpecFromURL(GURL("file:///tmp/test.html")));
}
// Test that invalid IP literals fail to parse.
TEST(NetUtilTest, ParseIPLiteralToNumber_FailParse) {
- net::IPAddressNumber number;
-
- EXPECT_FALSE(net::ParseIPLiteralToNumber("bad value", &number));
- EXPECT_FALSE(net::ParseIPLiteralToNumber("bad:value", &number));
- EXPECT_FALSE(net::ParseIPLiteralToNumber("", &number));
- EXPECT_FALSE(net::ParseIPLiteralToNumber("192.168.0.1:30", &number));
- EXPECT_FALSE(net::ParseIPLiteralToNumber(" 192.168.0.1 ", &number));
- EXPECT_FALSE(net::ParseIPLiteralToNumber("[::1]", &number));
+ IPAddressNumber number;
+
+ EXPECT_FALSE(ParseIPLiteralToNumber("bad value", &number));
+ EXPECT_FALSE(ParseIPLiteralToNumber("bad:value", &number));
+ EXPECT_FALSE(ParseIPLiteralToNumber("", &number));
+ EXPECT_FALSE(ParseIPLiteralToNumber("192.168.0.1:30", &number));
+ EXPECT_FALSE(ParseIPLiteralToNumber(" 192.168.0.1 ", &number));
+ EXPECT_FALSE(ParseIPLiteralToNumber("[::1]", &number));
}
// Test parsing an IPv4 literal.
TEST(NetUtilTest, ParseIPLiteralToNumber_IPv4) {
- net::IPAddressNumber number;
- EXPECT_TRUE(net::ParseIPLiteralToNumber("192.168.0.1", &number));
+ IPAddressNumber number;
+ EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
EXPECT_EQ("192,168,0,1", DumpIPNumber(number));
}
// Test parsing an IPv6 literal.
TEST(NetUtilTest, ParseIPLiteralToNumber_IPv6) {
- net::IPAddressNumber number;
- EXPECT_TRUE(net::ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
+ IPAddressNumber number;
+ EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPNumber(number));
}
// Test mapping an IPv4 address to an IPv6 address.
TEST(NetUtilTest, ConvertIPv4NumberToIPv6Number) {
- net::IPAddressNumber ipv4_number;
- EXPECT_TRUE(net::ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
+ IPAddressNumber ipv4_number;
+ EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
- net::IPAddressNumber ipv6_number =
- net::ConvertIPv4NumberToIPv6Number(ipv4_number);
+ IPAddressNumber ipv6_number =
+ ConvertIPv4NumberToIPv6Number(ipv4_number);
// ::ffff:192.168.1.1
EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
@@ -2064,10 +2063,10 @@ TEST(NetUtilTest, ParseCIDRBlock_Invalid) {
};
for (size_t i = 0; i < arraysize(bad_literals); ++i) {
- net::IPAddressNumber ip_number;
+ IPAddressNumber ip_number;
size_t prefix_length_in_bits;
- EXPECT_FALSE(net::ParseCIDRBlock(bad_literals[i],
+ EXPECT_FALSE(ParseCIDRBlock(bad_literals[i],
&ip_number,
&prefix_length_in_bits));
}
@@ -2075,10 +2074,10 @@ TEST(NetUtilTest, ParseCIDRBlock_Invalid) {
// Test parsing a valid CIDR notation literal.
TEST(NetUtilTest, ParseCIDRBlock_Valid) {
- net::IPAddressNumber ip_number;
+ IPAddressNumber ip_number;
size_t prefix_length_in_bits;
- EXPECT_TRUE(net::ParseCIDRBlock("192.168.0.1/11",
+ EXPECT_TRUE(ParseCIDRBlock("192.168.0.1/11",
&ip_number,
&prefix_length_in_bits));
@@ -2150,36 +2149,36 @@ TEST(NetUtilTest, IPNumberMatchesPrefix) {
tests[i].cidr_literal,
tests[i].ip_literal));
- net::IPAddressNumber ip_number;
- EXPECT_TRUE(net::ParseIPLiteralToNumber(tests[i].ip_literal, &ip_number));
+ IPAddressNumber ip_number;
+ EXPECT_TRUE(ParseIPLiteralToNumber(tests[i].ip_literal, &ip_number));
- net::IPAddressNumber ip_prefix;
+ IPAddressNumber ip_prefix;
size_t prefix_length_in_bits;
- EXPECT_TRUE(net::ParseCIDRBlock(tests[i].cidr_literal,
- &ip_prefix,
- &prefix_length_in_bits));
+ EXPECT_TRUE(ParseCIDRBlock(tests[i].cidr_literal,
+ &ip_prefix,
+ &prefix_length_in_bits));
EXPECT_EQ(tests[i].expected_to_match,
- net::IPNumberMatchesPrefix(ip_number,
- ip_prefix,
- prefix_length_in_bits));
+ IPNumberMatchesPrefix(ip_number,
+ ip_prefix,
+ prefix_length_in_bits));
}
}
// Verify GetNetworkList().
TEST(NetUtilTest, GetNetworkList) {
- net::NetworkInterfaceList list;
- ASSERT_TRUE(net::GetNetworkList(&list));
+ NetworkInterfaceList list;
+ ASSERT_TRUE(GetNetworkList(&list));
- for (net::NetworkInterfaceList::iterator it = list.begin();
+ for (NetworkInterfaceList::iterator it = list.begin();
it != list.end(); ++it) {
// Verify that the name is not empty.
EXPECT_FALSE(it->name.empty());
// Verify that the address is correct.
- EXPECT_TRUE(it->address.size() == net::kIPv4AddressSize ||
- it->address.size() == net::kIPv6AddressSize)
+ EXPECT_TRUE(it->address.size() == kIPv4AddressSize ||
+ it->address.size() == kIPv6AddressSize)
<< "Invalid address of size " << it->address.size();
bool all_zeroes = true;
for (size_t i = 0; i < it->address.size(); ++i) {
@@ -2191,3 +2190,5 @@ TEST(NetUtilTest, GetNetworkList) {
EXPECT_FALSE(all_zeroes);
}
}
+
+} // namespace net
generated by cgit v1.1 at 2025-10-13 23:07:33 +0000