// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: [email protected] (Laszlo Csomor)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
// Unit tests for long-path-aware open/mkdir/access/etc. on Windows, as well as
// for the supporting utility functions.
//
// This file is only used on Windows, it's empty on other platforms.
#if defined(_WIN32)
#define WIN32_LEAN_AND_MEAN
#include <google/protobuf/io/io_win32.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <wchar.h>
#include <windows.h>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include <gtest/gtest.h>
namespace google {
namespace protobuf {
namespace io {
namespace win32 {
namespace {
const char kUtf8Text[] = {
'h', 'i', ' ',
// utf-8: 11010000 10011111, utf-16: 100 0001 1111 = 0x041F
static_cast<char>(0xd0), static_cast<char>(0x9f),
// utf-8: 11010001 10000000, utf-16: 100 0100 0000 = 0x0440
static_cast<char>(0xd1), static_cast<char>(0x80),
// utf-8: 11010000 10111000, utf-16: 100 0011 1000 = 0x0438
static_cast<char>(0xd0), static_cast<char>(0xb8),
// utf-8: 11010000 10110010, utf-16: 100 0011 0010 = 0x0432
static_cast<char>(0xd0), static_cast<char>(0xb2),
// utf-8: 11010000 10110101, utf-16: 100 0011 0101 = 0x0435
static_cast<char>(0xd0), static_cast<char>(0xb5),
// utf-8: 11010001 10000010, utf-16: 100 0100 0010 = 0x0442
static_cast<char>(0xd1), static_cast<char>(0x82), 0
};
const wchar_t kUtf16Text[] = {
L'h', L'i', L' ',
L'\x41f', L'\x440', L'\x438', L'\x432', L'\x435', L'\x442', 0
};
using std::string;
using std::vector;
using std::wstring;
class IoWin32Test : public ::testing::Test {
public:
void SetUp();
void TearDown();
protected:
bool CreateAllUnder(wstring path);
bool DeleteAllUnder(wstring path);
WCHAR working_directory[MAX_PATH];
string test_tmpdir;
wstring wtest_tmpdir;
};
#define ASSERT_INITIALIZED \
{ \
EXPECT_FALSE(test_tmpdir.empty()); \
EXPECT_FALSE(wtest_tmpdir.empty()); \
}
namespace {
void StripTrailingSlashes(string* str) {
int i = str->size() - 1;
for (; i >= 0 && ((*str)[i] == '/' || (*str)[i] == '\\'); --i) {}
str->resize(i+1);
}
bool GetEnvVarAsUtf8(const WCHAR* name, string* result) {
DWORD size = ::GetEnvironmentVariableW(name, nullptr, 0);
if (size > 0 && GetLastError() != ERROR_ENVVAR_NOT_FOUND) {
std::unique_ptr<WCHAR[]> wcs(new WCHAR[size]);
::GetEnvironmentVariableW(name, wcs.get(), size);
// GetEnvironmentVariableA retrieves an Active-Code-Page-encoded text which
// we'd first need to convert to UTF-16 then to UTF-8, because there seems
// to be no API function to do that conversion directly.
// GetEnvironmentVariableW retrieves an UTF-16-encoded text, which we need
// to convert to UTF-8.
return strings::wcs_to_utf8(wcs.get(), result);
} else {
return false;
}
}
bool GetCwdAsUtf8(string* result) {
DWORD size = ::GetCurrentDirectoryW(0, nullptr);
if (size > 0) {
std::unique_ptr<WCHAR[]> wcs(new WCHAR[size]);
::GetCurrentDirectoryW(size, wcs.get());
// GetCurrentDirectoryA retrieves an Active-Code-Page-encoded text which
// we'd first need to convert to UTF-16 then to UTF-8, because there seems
// to be no API function to do that conversion directly.
// GetCurrentDirectoryW retrieves an UTF-16-encoded text, which we need
// to convert to UTF-8.
return strings::wcs_to_utf8(wcs.get(), result);
} else {
return false;
}
}
bool CreateEmptyFile(const wstring& path) {
HANDLE h = CreateFileW(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, NULL);
if (h == INVALID_HANDLE_VALUE) {
return false;
}
CloseHandle(h);
return true;
}
} // namespace
void IoWin32Test::SetUp() {
test_tmpdir.clear();
wtest_tmpdir.clear();
DWORD size = ::GetCurrentDirectoryW(MAX_PATH, working_directory);
EXPECT_GT(size, 0U);
EXPECT_LT(size, static_cast<DWORD>(MAX_PATH));
string tmp;
bool ok = false;
if (!ok) {
// Bazel sets this environment variable when it runs tests.
ok = GetEnvVarAsUtf8(L"TEST_TMPDIR", &tmp);
}
if (!ok) {
// Bazel 0.8.0 sets this environment for every build and test action.
ok = GetEnvVarAsUtf8(L"TEMP", &tmp);
}
if (!ok) {
// Bazel 0.8.0 sets this environment for every build and test action.
ok = GetEnvVarAsUtf8(L"TMP", &tmp);
}
if (!ok) {
// Fall back to using the current directory.
ok = GetCwdAsUtf8(&tmp);
}
if (!ok || tmp.empty()) {
FAIL() << "Cannot find a temp directory.";
}
StripTrailingSlashes(&tmp);
std::stringstream result;
// Deleting files and directories is asynchronous on Windows, and if TearDown
// just deleted the previous temp directory, sometimes we cannot recreate the
// same directory.
// Use a counter so every test method gets its own temp directory.
static unsigned int counter = 0;
result << tmp << "\\w32tst" << counter++ << ".tmp";
test_tmpdir = result.str();
wtest_tmpdir = testonly_utf8_to_winpath(test_tmpdir.c_str());
ASSERT_FALSE(wtest_tmpdir.empty());
ASSERT_TRUE(DeleteAllUnder(wtest_tmpdir));
ASSERT_TRUE(CreateAllUnder(wtest_tmpdir));
}
void IoWin32Test::TearDown() {
if (!wtest_tmpdir.empty()) {
DeleteAllUnder(wtest_tmpdir);
}
::SetCurrentDirectoryW(working_directory);
}
bool IoWin32Test::CreateAllUnder(wstring path) {
// Prepend UNC prefix if the path doesn't have it already. Don't bother
// checking if the path is shorter than MAX_PATH, let's just do it
// unconditionally.
if (path.find(L"\\\\?\\") != 0) {
path = wstring(L"\\\\?\\") + path;
}
if (::CreateDirectoryW(path.c_str(), nullptr) ||
GetLastError() == ERROR_ALREADY_EXISTS ||
GetLastError() == ERROR_ACCESS_DENIED) {
return true;
}
if (GetLastError() == ERROR_PATH_NOT_FOUND) {
size_t pos = path.find_last_of(L'\\');
if (pos != wstring::npos) {
wstring parent(path, 0, pos);
if (CreateAllUnder(parent) && CreateDirectoryW(path.c_str(), nullptr)) {
return true;
}
}
}
return false;
}
bool IoWin32Test::DeleteAllUnder(wstring path) {
static const wstring kDot(L".");
static const wstring kDotDot(L"..");
// Prepend UNC prefix if the path doesn't have it already. Don't bother
// checking if the path is shorter than MAX_PATH, let's just do it
// unconditionally.
if (path.find(L"\\\\?\\") != 0) {
path = wstring(L"\\\\?\\") + path;
}
// Append "\" if necessary.
if (path[path.size() - 1] != L'\\') {
path.push_back(L'\\');
}
WIN32_FIND_DATAW metadata;
HANDLE handle = ::FindFirstFileW((path + L"*").c_str(), &metadata);
if (handle == INVALID_HANDLE_VALUE) {
return true; // directory doesn't exist
}
bool result = true;
do {
wstring childname = metadata.cFileName;
if (kDot != childname && kDotDot != childname) {
wstring childpath = path + childname;
if ((metadata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
// If this is not a junction, delete its contents recursively.
// Finally delete this directory/junction too.
if (((metadata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0 &&
!DeleteAllUnder(childpath)) ||
!::RemoveDirectoryW(childpath.c_str())) {
result = false;
break;
}
} else {
if (!::DeleteFileW(childpath.c_str())) {
result = false;
break;
}
}
}
} while (::FindNextFileW(handle, &metadata));
::FindClose(handle);
return result;
}
TEST_F(IoWin32Test, AccessTest) {
ASSERT_INITIALIZED;
string path = test_tmpdir;
while (path.size() < MAX_PATH - 30) {
path += "\\accesstest";
EXPECT_EQ(mkdir(path.c_str(), 0644), 0);
}
string file = path + "\\file.txt";
int fd = open(file.c_str(), O_CREAT | O_WRONLY, 0644);
if (fd > 0) {
EXPECT_EQ(close(fd), 0);
} else {
EXPECT_TRUE(false);
}
EXPECT_EQ(access(test_tmpdir.c_str(), F_OK), 0);
EXPECT_EQ(access(path.c_str(), F_OK), 0);
EXPECT_EQ(access(path.c_str(), W_OK), 0);
EXPECT_EQ(access(file.c_str(), F_OK | W_OK), 0);
EXPECT_NE(access((file + ".blah").c_str(), F_OK), 0);
EXPECT_NE(access((file + ".blah").c_str(), W_OK), 0);
EXPECT_EQ(access(".", F_OK), 0);
EXPECT_EQ(access(".", W_OK), 0);
EXPECT_EQ(access((test_tmpdir + "/accesstest").c_str(), F_OK | W_OK), 0);
ASSERT_EQ(access((test_tmpdir + "/./normalize_me/.././accesstest").c_str(),
F_OK | W_OK),
0);
EXPECT_NE(access("io_win32_unittest.AccessTest.nonexistent", F_OK), 0);
EXPECT_NE(access("io_win32_unittest.AccessTest.nonexistent", W_OK), 0);
ASSERT_EQ(access("c:bad", F_OK), -1);
ASSERT_EQ(errno, ENOENT);
ASSERT_EQ(access("/tmp/bad", F_OK), -1);
ASSERT_EQ(errno, ENOENT);
ASSERT_EQ(access("\\bad", F_OK), -1);
ASSERT_EQ(errno, ENOENT);
}
TEST_F(IoWin32Test, OpenTest) {
ASSERT_INITIALIZED;
string path = test_tmpdir;
while (path.size() < MAX_PATH) {
path += "\\opentest";
EXPECT_EQ(mkdir(path.c_str(), 0644), 0);
}
string file = path + "\\file.txt";
int fd = open(file.c_str(), O_CREAT | O_WRONLY, 0644);
if (fd > 0) {
EXPECT_EQ(write(fd, "hello", 5), 5);
EXPECT_EQ(close(fd), 0);
} else {
EXPECT_TRUE(false);
}
ASSERT_EQ(open("c:bad.txt", O_CREAT | O_WRONLY, 0644), -1);
ASSERT_EQ(errno, ENOENT);
ASSERT_EQ(open("/tmp/bad.txt", O_CREAT | O_WRONLY, 0644), -1);
ASSERT_EQ(errno, ENOENT);
ASSERT_EQ(open("\\bad.txt", O_CREAT | O_WRONLY, 0644), -1);
ASSERT_EQ(errno, ENOENT);
}
TEST_F(IoWin32Test, MkdirTest) {
ASSERT_INITIALIZED;
string path = test_tmpdir;
do {
path += "\\mkdirtest";
ASSERT_EQ(mkdir(path.c_str(), 0644), 0);
} while (path.size() <= MAX_PATH);
ASSERT_EQ(mkdir("c:bad", 0644), -1);
ASSERT_EQ(errno, ENOENT);
ASSERT_EQ(mkdir("/tmp/bad", 0644), -1);
ASSERT_EQ(errno, ENOENT);
ASSERT_EQ(mkdir("\\bad", 0644), -1);
ASSERT_EQ(errno, ENOENT);
}
TEST_F(IoWin32Test, MkdirTestNonAscii) {
ASSERT_INITIALIZED;
// Create a non-ASCII path.
// Ensure that we can create the directory using CreateDirectoryW.
EXPECT_TRUE(CreateDirectoryW((wtest_tmpdir + L"\\1").c_str(), nullptr));
EXPECT_TRUE(CreateDirectoryW((wtest_tmpdir + L"\\1\\" + kUtf16Text).c_str(), nullptr));
// Ensure that we can create a very similarly named directory using mkdir.
// We don't attempt to delete and recreate the same directory, because on
// Windows, deleting files and directories seems to be asynchronous.
EXPECT_EQ(mkdir((test_tmpdir + "\\2").c_str(), 0644), 0);
EXPECT_EQ(mkdir((test_tmpdir + "\\2\\" + kUtf8Text).c_str(), 0644), 0);
}
TEST_F(IoWin32Test, ChdirTest) {
string path("C:\\");
EXPECT_EQ(access(path.c_str(), F_OK), 0);
ASSERT_EQ(chdir(path.c_str()), 0);
// Do not try to chdir into the test_tmpdir, it may already contain directory
// names with trailing dots.
// Instead test here with an obviously dot-trailed path. If the win32_chdir
// function would not convert the path to absolute and prefix with "\\?\" then
// the Win32 API would ignore the trailing dot, but because of the prefixing
// there'll be no path processing done, so we'll actually attempt to chdir
// into "C:\some\path\foo."
path = test_tmpdir + "/foo.";
EXPECT_EQ(mkdir(path.c_str(), 644), 0);
EXPECT_EQ(access(path.c_str(), F_OK), 0);
ASSERT_NE(chdir(path.c_str()), 0);
}
TEST_F(IoWin32Test, ChdirTestNonAscii) {
ASSERT_INITIALIZED;
// Create a directory with a non-ASCII path and ensure we can cd into it.
wstring wNonAscii(wtest_tmpdir + L"\\" + kUtf16Text);
string nonAscii;
EXPECT_TRUE(strings::wcs_to_utf8(wNonAscii.c_str(), &nonAscii));
EXPECT_TRUE(CreateDirectoryW(wNonAscii.c_str(), nullptr));
WCHAR cwd[MAX_PATH];
EXPECT_TRUE(GetCurrentDirectoryW(MAX_PATH, cwd));
// Ensure that we can cd into the path using SetCurrentDirectoryW.
EXPECT_TRUE(SetCurrentDirectoryW(wNonAscii.c_str()));
EXPECT_TRUE(SetCurrentDirectoryW(cwd));
// Ensure that we can cd into the path using chdir.
ASSERT_EQ(chdir(nonAscii.c_str()), 0);
// Ensure that the GetCurrentDirectoryW returns the desired path.
EXPECT_TRUE(GetCurrentDirectoryW(MAX_PATH, cwd));
ASSERT_EQ(wNonAscii, cwd);
}
TEST_F(IoWin32Test, ExpandWildcardsInRelativePathTest) {
wstring wNonAscii(wtest_tmpdir + L"\\" + kUtf16Text);
EXPECT_TRUE(CreateDirectoryW(wNonAscii.c_str(), nullptr));
// Create mock files we will test pattern matching on.
EXPECT_TRUE(CreateEmptyFile(wNonAscii + L"\\foo_a.proto"));
EXPECT_TRUE(CreateEmptyFile(wNonAscii + L"\\foo_b.proto"));
EXPECT_TRUE(CreateEmptyFile(wNonAscii + L"\\bar.proto"));
// `cd` into `wtest_tmpdir`.
EXPECT_TRUE(SetCurrentDirectoryW(wtest_tmpdir.c_str()));
int found_a = 0;
int found_b = 0;
vector<string> found_bad;
// Assert matching a relative path pattern. Results should also be relative.
ExpandWildcardsResult result =
ExpandWildcards(string(kUtf8Text) + "\\foo*.proto",
[&found_a, &found_b, &found_bad](const string& p) {
if (p == string(kUtf8Text) + "\\foo_a.proto") {
found_a++;
} else if (p == string(kUtf8Text) + "\\foo_b.proto") {
found_b++;
} else {
found_bad.push_back(p);
}
});
EXPECT_EQ(result, ExpandWildcardsResult::kSuccess);
EXPECT_EQ(found_a, 1);
EXPECT_EQ(found_b, 1);
if (!found_bad.empty()) {
FAIL() << found_bad[0];
}
// Assert matching the exact filename.
found_a = 0;
found_bad.clear();
result = ExpandWildcards(string(kUtf8Text) + "\\foo_a.proto",
[&found_a, &found_bad](const string& p) {
if (p == string(kUtf8Text) + "\\foo_a.proto") {
found_a++;
} else {
found_bad.push_back(p);
}
});
EXPECT_EQ(result, ExpandWildcardsResult::kSuccess);
EXPECT_EQ(found_a, 1);
if (!found_bad.empty()) {
FAIL() << found_bad[0];
}
}
TEST_F(IoWin32Test, ExpandWildcardsInAbsolutePathTest) {
wstring wNonAscii(wtest_tmpdir + L"\\" + kUtf16Text);
EXPECT_TRUE(CreateDirectoryW(wNonAscii.c_str(), nullptr));
// Create mock files we will test pattern matching on.
EXPECT_TRUE(CreateEmptyFile(wNonAscii + L"\\foo_a.proto"));
EXPECT_TRUE(CreateEmptyFile(wNonAscii + L"\\foo_b.proto"));
EXPECT_TRUE(CreateEmptyFile(wNonAscii + L"\\bar.proto"));
int found_a = 0;
int found_b = 0;
vector<string> found_bad;
// Assert matching an absolute path. The results should also use absolute
// path.
ExpandWildcardsResult result =
ExpandWildcards(string(test_tmpdir) + "\\" + kUtf8Text + "\\foo*.proto",
[this, &found_a, &found_b, &found_bad](const string& p) {
if (p == string(this->test_tmpdir) + "\\" + kUtf8Text +
"\\foo_a.proto") {
found_a++;
} else if (p == string(this->test_tmpdir) + "\\" +
kUtf8Text + "\\foo_b.proto") {
found_b++;
} else {
found_bad.push_back(p);
}
});
EXPECT_EQ(result, ExpandWildcardsResult::kSuccess);
EXPECT_EQ(found_a, 1);
EXPECT_EQ(found_b, 1);
if (!found_bad.empty()) {
FAIL() << found_bad[0];
}
// Assert matching the exact filename.
found_a = 0;
found_bad.clear();
result =
ExpandWildcards(string(test_tmpdir) + "\\" + kUtf8Text + "\\foo_a.proto",
[this, &found_a, &found_bad](const string& p) {
if (p == string(this->test_tmpdir) + "\\" + kUtf8Text +
"\\foo_a.proto") {
found_a++;
} else {
found_bad.push_back(p);
}
});
EXPECT_EQ(result, ExpandWildcardsResult::kSuccess);
EXPECT_EQ(found_a, 1);
if (!found_bad.empty()) {
FAIL() << found_bad[0];
}
}
TEST_F(IoWin32Test, ExpandWildcardsIgnoresDirectoriesTest) {
wstring wNonAscii(wtest_tmpdir + L"\\" + kUtf16Text);
EXPECT_TRUE(CreateDirectoryW(wNonAscii.c_str(), nullptr));
// Create mock files we will test pattern matching on.
EXPECT_TRUE(CreateEmptyFile(wNonAscii + L"\\foo_a.proto"));
EXPECT_TRUE(
CreateDirectoryW((wNonAscii + L"\\foo_b.proto").c_str(), nullptr));
EXPECT_TRUE(CreateEmptyFile(wNonAscii + L"\\foo_c.proto"));
// `cd` into `wtest_tmpdir`.
EXPECT_TRUE(SetCurrentDirectoryW(wtest_tmpdir.c_str()));
int found_a = 0;
int found_c = 0;
vector<string> found_bad;
// Assert that the pattern matches exactly the expected files, and using the
// absolute path as did the input pattern.
ExpandWildcardsResult result =
ExpandWildcards(string(kUtf8Text) + "\\foo*.proto",
[&found_a, &found_c, &found_bad](const string& p) {
if (p == string(kUtf8Text) + "\\foo_a.proto") {
found_a++;
} else if (p == string(kUtf8Text) + "\\foo_c.proto") {
found_c++;
} else {
found_bad.push_back(p);
}
});
EXPECT_EQ(result, ExpandWildcardsResult::kSuccess);
EXPECT_EQ(found_a, 1);
EXPECT_EQ(found_c, 1);
if (!found_bad.empty()) {
FAIL() << found_bad[0];
}
}
TEST_F(IoWin32Test, ExpandWildcardsFailsIfNoFileMatchesTest) {
wstring wNonAscii(wtest_tmpdir + L"\\" + kUtf16Text);
EXPECT_TRUE(CreateDirectoryW(wNonAscii.c_str(), nullptr));
// Create mock files we will test pattern matching on.
EXPECT_TRUE(CreateEmptyFile(wNonAscii + L"\\foo_a.proto"));
// `cd` into `wtest_tmpdir`.
EXPECT_TRUE(SetCurrentDirectoryW(wtest_tmpdir.c_str()));
// Control test: should match foo*.proto
ExpandWildcardsResult result =
ExpandWildcards(string(kUtf8Text) + "\\foo*.proto", [](const string&) {});
EXPECT_EQ(result, ExpandWildcardsResult::kSuccess);
// Control test: should match foo_a.proto
result = ExpandWildcards(string(kUtf8Text) + "\\foo_a.proto",
[](const string&) {});
EXPECT_EQ(result, ExpandWildcardsResult::kSuccess);
// Actual test: should not match anything.
result =
ExpandWildcards(string(kUtf8Text) + "\\bar*.proto", [](const string&) {});
ASSERT_EQ(result, ExpandWildcardsResult::kErrorNoMatchingFile);
}
TEST_F(IoWin32Test, AsWindowsPathTest) {
DWORD size = GetCurrentDirectoryW(0, nullptr);
std::unique_ptr<wchar_t[]> cwd_str(new wchar_t[size]);
EXPECT_GT(GetCurrentDirectoryW(size, cwd_str.get()), 0U);
wstring cwd = wstring(L"\\\\?\\") + cwd_str.get();
ASSERT_EQ(testonly_utf8_to_winpath("relative_mkdirtest"),
cwd + L"\\relative_mkdirtest");
ASSERT_EQ(testonly_utf8_to_winpath("preserve//\\trailing///"),
cwd + L"\\preserve\\trailing\\");
ASSERT_EQ(testonly_utf8_to_winpath("./normalize_me\\/../blah"),
cwd + L"\\blah");
std::ostringstream relpath;
for (wchar_t* p = cwd_str.get(); *p; ++p) {
if (*p == '/' || *p == '\\') {
relpath << "../";
}
}
relpath << ".\\/../\\./beyond-toplevel";
ASSERT_EQ(testonly_utf8_to_winpath(relpath.str().c_str()),
wstring(L"\\\\?\\") + cwd_str.get()[0] + L":\\beyond-toplevel");
// Absolute unix paths lack drive letters, driveless absolute windows paths
// do too. Neither can be converted to a drive-specifying absolute Windows
// path.
ASSERT_EQ(testonly_utf8_to_winpath("/absolute/unix/path"), L"");
// Though valid on Windows, we also don't support UNC paths (\\UNC\\blah).
ASSERT_EQ(testonly_utf8_to_winpath("\\driveless\\absolute"), L"");
// Though valid in cmd.exe, drive-relative paths are not supported.
ASSERT_EQ(testonly_utf8_to_winpath("c:foo"), L"");
ASSERT_EQ(testonly_utf8_to_winpath("c:/foo"), L"\\\\?\\c:\\foo");
ASSERT_EQ(testonly_utf8_to_winpath("\\\\?\\C:\\foo"), L"\\\\?\\C:\\foo");
}
TEST_F(IoWin32Test, Utf8Utf16ConversionTest) {
string mbs;
wstring wcs;
ASSERT_TRUE(strings::utf8_to_wcs(kUtf8Text, &wcs));
ASSERT_TRUE(strings::wcs_to_utf8(kUtf16Text, &mbs));
ASSERT_EQ(wcs, kUtf16Text);
ASSERT_EQ(mbs, kUtf8Text);
}
} // namespace
} // namespace win32
} // namespace io
} // namespace protobuf
} // namespace google
#endif // defined(_WIN32)
Codebase Browser
chromium