smbprovider/smbprovider_helper_test.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2017 The Chromium OS 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 <sstream>
 #include <vector>

 #include <gtest/gtest.h>
 #include <libsmbclient.h>

 #include "smbprovider/constants.h"
 #include "smbprovider/proto.h"
 #include "smbprovider/proto_bindings/directory_entry.pb.h"
 #include "smbprovider/smbprovider_helper.h"
 #include "smbprovider/smbprovider_test_helper.h"
 #include "smbprovider/temp_file_manager.h"

 namespace smbprovider {

 class SmbProviderHelperTest : public testing::Test {
  public:
   SmbProviderHelperTest() = default;
   SmbProviderHelperTest(const SmbProviderHelperTest&) = delete;
   SmbProviderHelperTest& operator=(const SmbProviderHelperTest&) = delete;

  protected:
   TempFileManager temp_file_manager_;
 };

 // Tests that AppendPath properly appends with or without the trailing separator
 // "/" on the base path.
 TEST_F(SmbProviderHelperTest, AppendPath) {
   EXPECT_EQ("smb://qnap/testshare/test",
             AppendPath("smb://qnap/testshare", "/test"));
   EXPECT_EQ("smb://qnap/testshare/test",
             AppendPath("smb://qnap/testshare/", "/test"));
   EXPECT_EQ("smb://qnap/testshare/test",
             AppendPath("smb://qnap/testshare", "test"));
   EXPECT_EQ("smb://qnap/testshare/test",
             AppendPath("smb://qnap/testshare/", "test"));
   EXPECT_EQ("smb://qnap/testshare", AppendPath("smb://qnap/testshare/", "/"));
   EXPECT_EQ("smb://qnap/testshare", AppendPath("smb://qnap/testshare/", ""));
 }

 // Should return true on "." and ".." entries.
 TEST_F(SmbProviderHelperTest, IsSelfOrParentDir) {
   EXPECT_TRUE(IsSelfOrParentDir("."));
   EXPECT_TRUE(IsSelfOrParentDir(".."));
   EXPECT_FALSE(IsSelfOrParentDir("/"));
   EXPECT_FALSE(IsSelfOrParentDir("test.jpg"));
 }

 // Only SMBC_DIR and SMBC_FILE should return true.
 TEST_F(SmbProviderHelperTest, IsFileOrDir) {
   EXPECT_TRUE(IsFileOrDir(SMBC_DIR));
   EXPECT_TRUE(IsFileOrDir(SMBC_FILE));

   EXPECT_FALSE(IsFileOrDir(SMBC_WORKGROUP));
   EXPECT_FALSE(IsFileOrDir(SMBC_SERVER));
   EXPECT_FALSE(IsFileOrDir(SMBC_FILE_SHARE));
   EXPECT_FALSE(IsFileOrDir(SMBC_PRINTER_SHARE));
   EXPECT_FALSE(IsFileOrDir(SMBC_COMMS_SHARE));
   EXPECT_FALSE(IsFileOrDir(SMBC_IPC_SHARE));
   EXPECT_FALSE(IsFileOrDir(SMBC_LINK));
 }

 // Only SMBC_FILE_SHARE should return true.
 TEST_F(SmbProviderHelperTest, IsSmbShare) {
   EXPECT_TRUE(IsSmbShare(SMBC_FILE_SHARE));

   EXPECT_FALSE(IsSmbShare(SMBC_DIR));
   EXPECT_FALSE(IsSmbShare(SMBC_FILE));
   EXPECT_FALSE(IsSmbShare(SMBC_WORKGROUP));
   EXPECT_FALSE(IsSmbShare(SMBC_SERVER));
   EXPECT_FALSE(IsSmbShare(SMBC_PRINTER_SHARE));
   EXPECT_FALSE(IsSmbShare(SMBC_COMMS_SHARE));
   EXPECT_FALSE(IsSmbShare(SMBC_IPC_SHARE));
   EXPECT_FALSE(IsSmbShare(SMBC_LINK));
 }

 // Errors should be returned correctly.
 TEST_F(SmbProviderHelperTest, GetErrorFromErrno) {
   EXPECT_EQ(ERROR_ACCESS_DENIED, GetErrorFromErrno(EPERM));
   EXPECT_EQ(ERROR_ACCESS_DENIED, GetErrorFromErrno(EACCES));

   EXPECT_EQ(ERROR_NOT_FOUND, GetErrorFromErrno(ENOENT));

   EXPECT_EQ(ERROR_TOO_MANY_OPENED, GetErrorFromErrno(EMFILE));
   EXPECT_EQ(ERROR_TOO_MANY_OPENED, GetErrorFromErrno(ENFILE));

   EXPECT_EQ(ERROR_NOT_A_DIRECTORY, GetErrorFromErrno(ENOTDIR));

   EXPECT_EQ(ERROR_NOT_A_FILE, GetErrorFromErrno(EISDIR));

   EXPECT_EQ(ERROR_NOT_EMPTY, GetErrorFromErrno(ENOTEMPTY));

   EXPECT_EQ(ERROR_EXISTS, GetErrorFromErrno(EEXIST));

   EXPECT_EQ(ERROR_INVALID_OPERATION, GetErrorFromErrno(EINVAL));

   EXPECT_EQ(ERROR_SMB1_UNSUPPORTED, GetErrorFromErrno(ECONNABORTED));

   EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(EBADF));
   EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(ENODEV));
   EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(ETIMEDOUT));

   // Errors without an explicit mapping get mapped
   // to ERROR_FAILED.
   EXPECT_EQ(ERROR_FAILED, GetErrorFromErrno(ENOSPC));
   EXPECT_EQ(ERROR_FAILED, GetErrorFromErrno(ESPIPE));
 }

 // Errors should be returned correctly.
 TEST_F(SmbProviderHelperTest, GetErrorFromErrnoForReadDir) {
   EXPECT_EQ(ERROR_ACCESS_DENIED, GetErrorFromErrnoForReadDir(EPERM));
   EXPECT_EQ(ERROR_ACCESS_DENIED, GetErrorFromErrnoForReadDir(EACCES));

   EXPECT_EQ(ERROR_NOT_FOUND, GetErrorFromErrnoForReadDir(ENOENT));
   // EINVAL is returned when Samba attempts to parse a hostname
   // (eg. \\qnap\testshare).
   EXPECT_EQ(ERROR_NOT_FOUND, GetErrorFromErrnoForReadDir(EINVAL));

   EXPECT_EQ(ERROR_TOO_MANY_OPENED, GetErrorFromErrnoForReadDir(EMFILE));
   EXPECT_EQ(ERROR_TOO_MANY_OPENED, GetErrorFromErrnoForReadDir(ENFILE));

   EXPECT_EQ(ERROR_NOT_A_DIRECTORY, GetErrorFromErrnoForReadDir(ENOTDIR));

   EXPECT_EQ(ERROR_NOT_A_FILE, GetErrorFromErrnoForReadDir(EISDIR));

   EXPECT_EQ(ERROR_NOT_EMPTY, GetErrorFromErrnoForReadDir(ENOTEMPTY));

   EXPECT_EQ(ERROR_EXISTS, GetErrorFromErrnoForReadDir(EEXIST));

   EXPECT_EQ(ERROR_SMB1_UNSUPPORTED, GetErrorFromErrnoForReadDir(ECONNABORTED));

   EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(EBADF));
   EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(ENODEV));
   EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(ETIMEDOUT));

   // Errors without an explicit mapping get mapped
   // to ERROR_FAILED.
   EXPECT_EQ(ERROR_FAILED, GetErrorFromErrnoForReadDir(ENOSPC));
   EXPECT_EQ(ERROR_FAILED, GetErrorFromErrnoForReadDir(ESPIPE));
 }

 // IsDirectory should only return true on directory stats.
 TEST_F(SmbProviderHelperTest, IsDirectory) {
   struct stat dir_info;
   dir_info.st_mode = 16877;  // Dir mode
   struct stat file_info;
   file_info.st_mode = 33188;  // File mode

   EXPECT_TRUE(IsDirectory(dir_info));
   EXPECT_FALSE(IsDirectory(file_info));
 }

 // IsFile should only return true on File stats.
 TEST_F(SmbProviderHelperTest, IsFile) {
   struct stat dir_info;
   dir_info.st_mode = 16877;  // Dir mode
   struct stat file_info;
   file_info.st_mode = 33188;  // File mode

   EXPECT_TRUE(IsFile(file_info));
   EXPECT_FALSE(IsFile(dir_info));
 }

 // IsValidOpenFileFlags should return true on valid flags.
 TEST_F(SmbProviderHelperTest, IsValidOpenFileFlags) {
   EXPECT_TRUE(IsValidOpenFileFlags(O_RDWR));
   EXPECT_TRUE(IsValidOpenFileFlags(O_RDONLY));
   EXPECT_TRUE(IsValidOpenFileFlags(O_WRONLY));
   EXPECT_FALSE(IsValidOpenFileFlags(O_CREAT));
   EXPECT_FALSE(IsValidOpenFileFlags(O_TRUNC));
 }

 TEST_F(SmbProviderHelperTest, ReadFromFDErrorOnInvalidFd) {
   std::vector<uint8_t> buffer;
   int32_t error;

   WriteFileOptionsProto proto = CreateWriteFileOptionsProto(
       0 /* mount_id */, 1 /* file_id */, 0 /* offset */, 0 /* length */);

   // Create a file descriptor that is invalid.
   base::ScopedFD invalid_fd;
   EXPECT_FALSE(invalid_fd.is_valid());

   // Should return an error when passing in an invalid file descriptor.
   EXPECT_FALSE(ReadFromFD(proto, invalid_fd, &error, &buffer));
   EXPECT_EQ(ERROR_DBUS_PARSE_FAILED, static_cast<ErrorType>(error));
 }

 TEST_F(SmbProviderHelperTest, ReadFromFDFailsWithLengthLargerThanData) {
   const std::vector<uint8_t> data = {0, 1, 2, 3};

   // Send in options with length larger than the data.
   WriteFileOptionsProto proto = CreateWriteFileOptionsProto(
       0 /* mount_id */, 1 /* file_id */, 0 /* offset */, data.size() + 1);
   int32_t error;

   // Ensure that the fd created is valid.
   base::ScopedFD fd(temp_file_manager_.CreateTempFile(data).release());
   EXPECT_TRUE(fd.is_valid());

   // Should fail since it can't read that much data.
   std::vector<uint8_t> buffer;
   EXPECT_FALSE(ReadFromFD(proto, fd, &error, &buffer));
   EXPECT_EQ(ERROR_IO, static_cast<ErrorType>(error));
 }

 TEST_F(SmbProviderHelperTest, ReadFromFDSucceedsWithLengthSmallerThanData) {
   const std::vector<uint8_t> data = {0, 1, 2, 3};

   // Send in options with length smaller than the data.
   WriteFileOptionsProto proto = CreateWriteFileOptionsProto(
       0 /* mount_id */, 1 /* file_id */, 0 /* offset */, data.size() - 1);
   int32_t error;

   // Ensure that the fd created is valid.
   base::ScopedFD fd(temp_file_manager_.CreateTempFile(data).release());
   EXPECT_TRUE(fd.is_valid());

   // Should be OK.
   std::vector<uint8_t> buffer;
   EXPECT_TRUE(ReadFromFD(proto, fd, &error, &buffer));

   // Should be equal to the truncated data.
   const std::vector<uint8_t> expected = {0, 1, 2};
   EXPECT_EQ(expected, buffer);
 }

 TEST_F(SmbProviderHelperTest, ReadFromFDSucceedsWithExactSize) {
   const std::vector<uint8_t> data = {0, 1, 2, 3};

   // Send in options with length equal to the data.
   WriteFileOptionsProto proto = CreateWriteFileOptionsProto(
       0 /* mount_id */, 1 /* file_id */, 0 /* offset */, data.size());
   int32_t error;

   // Ensure that the fd created is valid.
   base::ScopedFD fd(temp_file_manager_.CreateTempFile(data).release());
   EXPECT_TRUE(fd.is_valid());

   // Should be OK.
   std::vector<uint8_t> buffer;
   EXPECT_TRUE(ReadFromFD(proto, fd, &error, &buffer));
   EXPECT_EQ(data, buffer);
 }

 // SplitPath correctly splits a relative path into a vector of its components.
 TEST_F(SmbProviderHelperTest, SplitPathCorrectlySplitsPath) {
   const std::string relative_path = "/testShare/dogs/lab.jpg";

   PathParts parts = SplitPath(relative_path);

   EXPECT_EQ(4, parts.size());
   EXPECT_EQ("/", parts[0]);
   EXPECT_EQ("testShare", parts[1]);
   EXPECT_EQ("dogs", parts[2]);
   EXPECT_EQ("lab.jpg", parts[3]);
 }

 // SplitPath correctly splits a standalone leading slash and a standalone
 // directory.
 TEST_F(SmbProviderHelperTest, SplitPathCorrectlySplitsRoot) {
   const std::string root_path = "/";

   PathParts parts = SplitPath(root_path);

   EXPECT_EQ(1, parts.size());
   EXPECT_EQ("/", parts[0]);
 }

 // SplitPath correctly splits a standalone directory.
 TEST_F(SmbProviderHelperTest, SplitPathCorrectlySplitsDirPath) {
   const std::string dir_path = "/foo";

   PathParts parts = SplitPath(dir_path);

   EXPECT_EQ(2, parts.size());
   EXPECT_EQ("/", parts[0]);
   EXPECT_EQ("foo", parts[1]);
 }

 // RemoveUrlScheme correctly removes the SMB Url scheme from an SMB Url.
 TEST_F(SmbProviderHelperTest, RemoveUrlSchemeCorrectlyRemovesUrl) {
   EXPECT_EQ("/testShare/dogs", RemoveURLScheme("smb://testShare/dogs"));
 }

 // GetFileName correctly returns root when passed "smb://".
 TEST_F(SmbProviderHelperTest, GetFileNameReturnsRoot) {
   const std::string full_path = "smb://";

   EXPECT_EQ("/", GetFileName(full_path));
 }

 // GetFileName correctly returns the filename when passed "smb://foo".
 TEST_F(SmbProviderHelperTest, GetFileNameReturnsFileNameOnSingleDepth) {
   const std::string full_path = "smb://foo";

   EXPECT_EQ("foo", GetFileName(full_path));
 }

 // GetFileName correctly returns the filename from an SMB Url.
 TEST_F(SmbProviderHelperTest, GetFileNameReturnsFileName) {
   const std::string full_path = "smb://testShare/dogs/lab.jpg";

   EXPECT_EQ("lab.jpg", GetFileName(full_path));
 }

 // GetDirPath correctly returns root when passed "smb://".
 TEST_F(SmbProviderHelperTest, GetDirPathReturnsRoot) {
   const std::string full_path = "smb://";

   EXPECT_EQ("/", GetDirPath(full_path));
 }

 // GetDirPath correctly returns the dirpath when passed "smb://foo".
 TEST_F(SmbProviderHelperTest, GetDirPathReturnsRootOnSingleDepth) {
   const std::string full_path = "smb://foo";

   EXPECT_EQ("/", GetDirPath(full_path));
 }

 // GetDirPath correctly returns the dirpath from an SMB Url.
 TEST_F(SmbProviderHelperTest, GetDirPathReturnsParent) {
   const std::string full_path = "smb://testShare/dogs/lab.jpg";

   EXPECT_EQ("/testShare/dogs", GetDirPath(full_path));
 }

 TEST_F(SmbProviderHelperTest, ShouldReportCreateDirError) {
   EXPECT_FALSE(
       ShouldReportCreateDirError(0 /* result */, false /* ignore_existing */));
   EXPECT_FALSE(
       ShouldReportCreateDirError(0 /* result */, true /* ignore_existing */));
   EXPECT_FALSE(ShouldReportCreateDirError(EEXIST, true /* ignore_existing */));
   EXPECT_TRUE(ShouldReportCreateDirError(EEXIST, false /* ignore_existing */));
   EXPECT_TRUE(ShouldReportCreateDirError(EPERM, false /* ignore_existing */));
   EXPECT_TRUE(ShouldReportCreateDirError(EPERM, true /* ignore_existing */));
 }

 // GetOpenFilePermissions correctly returns permissions.
 TEST_F(SmbProviderHelperTest, GetOpenFilePermissions) {
   OpenFileOptionsProto open_file_proto_read = CreateOpenFileOptionsProto(
       3 /* mount_id */, "smb://testShare/dir1/pic.png", false /* writeable */);
   EXPECT_EQ(O_RDONLY, GetOpenFilePermissions(open_file_proto_read));

   OpenFileOptionsProto open_file_proto_read_write = CreateOpenFileOptionsProto(
       3 /* mount_id */, "smb://testShare/dir1/pic.png", true /* writeable */);
   EXPECT_EQ(O_RDWR, GetOpenFilePermissions(open_file_proto_read_write));

   TruncateOptionsProto truncate_proto_blank;
   EXPECT_EQ(O_WRONLY, GetOpenFilePermissions(truncate_proto_blank));

   CopyEntryOptionsProto copy_entry_proto_blank;
   EXPECT_EQ(O_RDONLY, GetOpenFilePermissions(copy_entry_proto_blank));
 }

 TEST_F(SmbProviderHelperTest, GetOpenFilePermissionsBoolean) {
   EXPECT_EQ(O_RDWR, GetOpenFilePermissions(true));

   EXPECT_EQ(O_RDONLY, GetOpenFilePermissions(false));
 }

 namespace {

 std::string ToString(ErrorType error) {
   std::ostringstream out;
   out << error;
   return out.str();
 }

 }  // namespace

 TEST_F(SmbProviderHelperTest, ErrorTypeOutputOperator) {
   EXPECT_EQ(ToString(ERROR_NONE), "ERROR_NONE");
   EXPECT_EQ(ToString(ERROR_OK), "ERROR_OK");
   EXPECT_EQ(ToString(ERROR_FAILED), "ERROR_FAILED");
   EXPECT_EQ(ToString(ERROR_IN_USE), "ERROR_IN_USE");
   EXPECT_EQ(ToString(ERROR_EXISTS), "ERROR_EXISTS");
   EXPECT_EQ(ToString(ERROR_NOT_FOUND), "ERROR_NOT_FOUND");
   EXPECT_EQ(ToString(ERROR_ACCESS_DENIED), "ERROR_ACCESS_DENIED");
   EXPECT_EQ(ToString(ERROR_TOO_MANY_OPENED), "ERROR_TOO_MANY_OPENED");
   EXPECT_EQ(ToString(ERROR_NO_MEMORY), "ERROR_NO_MEMORY");
   EXPECT_EQ(ToString(ERROR_NO_SPACE), "ERROR_NO_SPACE");
   EXPECT_EQ(ToString(ERROR_NOT_A_DIRECTORY), "ERROR_NOT_A_DIRECTORY");
   EXPECT_EQ(ToString(ERROR_INVALID_OPERATION), "ERROR_INVALID_OPERATION");
   EXPECT_EQ(ToString(ERROR_SECURITY), "ERROR_SECURITY");
   EXPECT_EQ(ToString(ERROR_ABORT), "ERROR_ABORT");
   EXPECT_EQ(ToString(ERROR_NOT_A_FILE), "ERROR_NOT_A_FILE");
   EXPECT_EQ(ToString(ERROR_NOT_EMPTY), "ERROR_NOT_EMPTY");
   EXPECT_EQ(ToString(ERROR_INVALID_URL), "ERROR_INVALID_URL");
   EXPECT_EQ(ToString(ERROR_IO), "ERROR_IO");
   EXPECT_EQ(ToString(ERROR_PROVIDER_ERROR_COUNT), "ERROR_PROVIDER_ERROR_COUNT");
   EXPECT_EQ(ToString(ERROR_DBUS_PARSE_FAILED), "ERROR_DBUS_PARSE_FAILED");
   EXPECT_EQ(ToString(ERROR_COPY_PENDING), "ERROR_COPY_PENDING");
   EXPECT_EQ(ToString(ERROR_COPY_FAILED), "ERROR_COPY_FAILED");
   EXPECT_EQ(ToString(ERROR_SMB1_UNSUPPORTED), "ERROR_SMB1_UNSUPPORTED");
   EXPECT_EQ(ToString(ERROR_OPERATION_PENDING), "ERROR_OPERATION_PENDING");
   EXPECT_EQ(ToString(ERROR_OPERATION_FAILED), "ERROR_OPERATION_FAILED");
   EXPECT_EQ(ToString(ErrorType(987654)), "ERROR_987654");
 }

 }  // namespace smbprovider
	// Copyright 2017 The Chromium OS 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 <sstream>
	#include <vector>

	#include <gtest/gtest.h>
	#include <libsmbclient.h>

	#include "smbprovider/constants.h"
	#include "smbprovider/proto.h"
	#include "smbprovider/proto_bindings/directory_entry.pb.h"
	#include "smbprovider/smbprovider_helper.h"
	#include "smbprovider/smbprovider_test_helper.h"
	#include "smbprovider/temp_file_manager.h"

	namespace smbprovider {

	class SmbProviderHelperTest : public testing::Test {
	public:
	SmbProviderHelperTest() = default;
	SmbProviderHelperTest(const SmbProviderHelperTest&) = delete;
	SmbProviderHelperTest& operator=(const SmbProviderHelperTest&) = delete;

	protected:
	TempFileManager temp_file_manager_;
	};

	// Tests that AppendPath properly appends with or without the trailing separator
	// "/" on the base path.
	TEST_F(SmbProviderHelperTest, AppendPath) {
	EXPECT_EQ("smb://qnap/testshare/test",
	AppendPath("smb://qnap/testshare", "/test"));
	EXPECT_EQ("smb://qnap/testshare/test",
	AppendPath("smb://qnap/testshare/", "/test"));
	EXPECT_EQ("smb://qnap/testshare/test",
	AppendPath("smb://qnap/testshare", "test"));
	EXPECT_EQ("smb://qnap/testshare/test",
	AppendPath("smb://qnap/testshare/", "test"));
	EXPECT_EQ("smb://qnap/testshare", AppendPath("smb://qnap/testshare/", "/"));
	EXPECT_EQ("smb://qnap/testshare", AppendPath("smb://qnap/testshare/", ""));
	}

	// Should return true on "." and ".." entries.
	TEST_F(SmbProviderHelperTest, IsSelfOrParentDir) {
	EXPECT_TRUE(IsSelfOrParentDir("."));
	EXPECT_TRUE(IsSelfOrParentDir(".."));
	EXPECT_FALSE(IsSelfOrParentDir("/"));
	EXPECT_FALSE(IsSelfOrParentDir("test.jpg"));
	}

	// Only SMBC_DIR and SMBC_FILE should return true.
	TEST_F(SmbProviderHelperTest, IsFileOrDir) {
	EXPECT_TRUE(IsFileOrDir(SMBC_DIR));
	EXPECT_TRUE(IsFileOrDir(SMBC_FILE));

	EXPECT_FALSE(IsFileOrDir(SMBC_WORKGROUP));
	EXPECT_FALSE(IsFileOrDir(SMBC_SERVER));
	EXPECT_FALSE(IsFileOrDir(SMBC_FILE_SHARE));
	EXPECT_FALSE(IsFileOrDir(SMBC_PRINTER_SHARE));
	EXPECT_FALSE(IsFileOrDir(SMBC_COMMS_SHARE));
	EXPECT_FALSE(IsFileOrDir(SMBC_IPC_SHARE));
	EXPECT_FALSE(IsFileOrDir(SMBC_LINK));
	}

	// Only SMBC_FILE_SHARE should return true.
	TEST_F(SmbProviderHelperTest, IsSmbShare) {
	EXPECT_TRUE(IsSmbShare(SMBC_FILE_SHARE));

	EXPECT_FALSE(IsSmbShare(SMBC_DIR));
	EXPECT_FALSE(IsSmbShare(SMBC_FILE));
	EXPECT_FALSE(IsSmbShare(SMBC_WORKGROUP));
	EXPECT_FALSE(IsSmbShare(SMBC_SERVER));
	EXPECT_FALSE(IsSmbShare(SMBC_PRINTER_SHARE));
	EXPECT_FALSE(IsSmbShare(SMBC_COMMS_SHARE));
	EXPECT_FALSE(IsSmbShare(SMBC_IPC_SHARE));
	EXPECT_FALSE(IsSmbShare(SMBC_LINK));
	}

	// Errors should be returned correctly.
	TEST_F(SmbProviderHelperTest, GetErrorFromErrno) {
	EXPECT_EQ(ERROR_ACCESS_DENIED, GetErrorFromErrno(EPERM));
	EXPECT_EQ(ERROR_ACCESS_DENIED, GetErrorFromErrno(EACCES));

	EXPECT_EQ(ERROR_NOT_FOUND, GetErrorFromErrno(ENOENT));

	EXPECT_EQ(ERROR_TOO_MANY_OPENED, GetErrorFromErrno(EMFILE));
	EXPECT_EQ(ERROR_TOO_MANY_OPENED, GetErrorFromErrno(ENFILE));

	EXPECT_EQ(ERROR_NOT_A_DIRECTORY, GetErrorFromErrno(ENOTDIR));

	EXPECT_EQ(ERROR_NOT_A_FILE, GetErrorFromErrno(EISDIR));

	EXPECT_EQ(ERROR_NOT_EMPTY, GetErrorFromErrno(ENOTEMPTY));

	EXPECT_EQ(ERROR_EXISTS, GetErrorFromErrno(EEXIST));

	EXPECT_EQ(ERROR_INVALID_OPERATION, GetErrorFromErrno(EINVAL));

	EXPECT_EQ(ERROR_SMB1_UNSUPPORTED, GetErrorFromErrno(ECONNABORTED));

	EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(EBADF));
	EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(ENODEV));
	EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(ETIMEDOUT));

	// Errors without an explicit mapping get mapped
	// to ERROR_FAILED.
	EXPECT_EQ(ERROR_FAILED, GetErrorFromErrno(ENOSPC));
	EXPECT_EQ(ERROR_FAILED, GetErrorFromErrno(ESPIPE));
	}

	// Errors should be returned correctly.
	TEST_F(SmbProviderHelperTest, GetErrorFromErrnoForReadDir) {
	EXPECT_EQ(ERROR_ACCESS_DENIED, GetErrorFromErrnoForReadDir(EPERM));
	EXPECT_EQ(ERROR_ACCESS_DENIED, GetErrorFromErrnoForReadDir(EACCES));

	EXPECT_EQ(ERROR_NOT_FOUND, GetErrorFromErrnoForReadDir(ENOENT));
	// EINVAL is returned when Samba attempts to parse a hostname
	// (eg. \\qnap\testshare).
	EXPECT_EQ(ERROR_NOT_FOUND, GetErrorFromErrnoForReadDir(EINVAL));

	EXPECT_EQ(ERROR_TOO_MANY_OPENED, GetErrorFromErrnoForReadDir(EMFILE));
	EXPECT_EQ(ERROR_TOO_MANY_OPENED, GetErrorFromErrnoForReadDir(ENFILE));

	EXPECT_EQ(ERROR_NOT_A_DIRECTORY, GetErrorFromErrnoForReadDir(ENOTDIR));

	EXPECT_EQ(ERROR_NOT_A_FILE, GetErrorFromErrnoForReadDir(EISDIR));

	EXPECT_EQ(ERROR_NOT_EMPTY, GetErrorFromErrnoForReadDir(ENOTEMPTY));

	EXPECT_EQ(ERROR_EXISTS, GetErrorFromErrnoForReadDir(EEXIST));

	EXPECT_EQ(ERROR_SMB1_UNSUPPORTED, GetErrorFromErrnoForReadDir(ECONNABORTED));

	EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(EBADF));
	EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(ENODEV));
	EXPECT_EQ(ERROR_OPERATION_FAILED, GetErrorFromErrno(ETIMEDOUT));

	// Errors without an explicit mapping get mapped
	// to ERROR_FAILED.
	EXPECT_EQ(ERROR_FAILED, GetErrorFromErrnoForReadDir(ENOSPC));
	EXPECT_EQ(ERROR_FAILED, GetErrorFromErrnoForReadDir(ESPIPE));
	}

	// IsDirectory should only return true on directory stats.
	TEST_F(SmbProviderHelperTest, IsDirectory) {
	struct stat dir_info;
	dir_info.st_mode = 16877; // Dir mode
	struct stat file_info;
	file_info.st_mode = 33188; // File mode

	EXPECT_TRUE(IsDirectory(dir_info));
	EXPECT_FALSE(IsDirectory(file_info));
	}

	// IsFile should only return true on File stats.
	TEST_F(SmbProviderHelperTest, IsFile) {
	struct stat dir_info;
	dir_info.st_mode = 16877; // Dir mode
	struct stat file_info;
	file_info.st_mode = 33188; // File mode

	EXPECT_TRUE(IsFile(file_info));
	EXPECT_FALSE(IsFile(dir_info));
	}

	// IsValidOpenFileFlags should return true on valid flags.
	TEST_F(SmbProviderHelperTest, IsValidOpenFileFlags) {
	EXPECT_TRUE(IsValidOpenFileFlags(O_RDWR));
	EXPECT_TRUE(IsValidOpenFileFlags(O_RDONLY));
	EXPECT_TRUE(IsValidOpenFileFlags(O_WRONLY));
	EXPECT_FALSE(IsValidOpenFileFlags(O_CREAT));
	EXPECT_FALSE(IsValidOpenFileFlags(O_TRUNC));
	}

	TEST_F(SmbProviderHelperTest, ReadFromFDErrorOnInvalidFd) {
	std::vector<uint8_t> buffer;
	int32_t error;

	WriteFileOptionsProto proto = CreateWriteFileOptionsProto(
	0 /* mount_id /, 1 / file_id /, 0 / offset /, 0 / length */);

	// Create a file descriptor that is invalid.
	base::ScopedFD invalid_fd;
	EXPECT_FALSE(invalid_fd.is_valid());

	// Should return an error when passing in an invalid file descriptor.
	EXPECT_FALSE(ReadFromFD(proto, invalid_fd, &error, &buffer));
	EXPECT_EQ(ERROR_DBUS_PARSE_FAILED, static_cast<ErrorType>(error));
	}

	TEST_F(SmbProviderHelperTest, ReadFromFDFailsWithLengthLargerThanData) {
	const std::vector<uint8_t> data = {0, 1, 2, 3};

	// Send in options with length larger than the data.
	WriteFileOptionsProto proto = CreateWriteFileOptionsProto(
	0 /* mount_id /, 1 / file_id /, 0 / offset */, data.size() + 1);
	int32_t error;

	// Ensure that the fd created is valid.
	base::ScopedFD fd(temp_file_manager_.CreateTempFile(data).release());
	EXPECT_TRUE(fd.is_valid());

	// Should fail since it can't read that much data.
	std::vector<uint8_t> buffer;
	EXPECT_FALSE(ReadFromFD(proto, fd, &error, &buffer));
	EXPECT_EQ(ERROR_IO, static_cast<ErrorType>(error));
	}

	TEST_F(SmbProviderHelperTest, ReadFromFDSucceedsWithLengthSmallerThanData) {
	const std::vector<uint8_t> data = {0, 1, 2, 3};

	// Send in options with length smaller than the data.
	WriteFileOptionsProto proto = CreateWriteFileOptionsProto(
	0 /* mount_id /, 1 / file_id /, 0 / offset */, data.size() - 1);
	int32_t error;

	// Ensure that the fd created is valid.
	base::ScopedFD fd(temp_file_manager_.CreateTempFile(data).release());
	EXPECT_TRUE(fd.is_valid());

	// Should be OK.
	std::vector<uint8_t> buffer;
	EXPECT_TRUE(ReadFromFD(proto, fd, &error, &buffer));

	// Should be equal to the truncated data.
	const std::vector<uint8_t> expected = {0, 1, 2};
	EXPECT_EQ(expected, buffer);
	}

	TEST_F(SmbProviderHelperTest, ReadFromFDSucceedsWithExactSize) {
	const std::vector<uint8_t> data = {0, 1, 2, 3};

	// Send in options with length equal to the data.
	WriteFileOptionsProto proto = CreateWriteFileOptionsProto(
	0 /* mount_id /, 1 / file_id /, 0 / offset */, data.size());
	int32_t error;

	// Ensure that the fd created is valid.
	base::ScopedFD fd(temp_file_manager_.CreateTempFile(data).release());
	EXPECT_TRUE(fd.is_valid());

	// Should be OK.
	std::vector<uint8_t> buffer;
	EXPECT_TRUE(ReadFromFD(proto, fd, &error, &buffer));
	EXPECT_EQ(data, buffer);
	}

	// SplitPath correctly splits a relative path into a vector of its components.
	TEST_F(SmbProviderHelperTest, SplitPathCorrectlySplitsPath) {
	const std::string relative_path = "/testShare/dogs/lab.jpg";

	PathParts parts = SplitPath(relative_path);

	EXPECT_EQ(4, parts.size());
	EXPECT_EQ("/", parts[0]);
	EXPECT_EQ("testShare", parts[1]);
	EXPECT_EQ("dogs", parts[2]);
	EXPECT_EQ("lab.jpg", parts[3]);
	}

	// SplitPath correctly splits a standalone leading slash and a standalone
	// directory.
	TEST_F(SmbProviderHelperTest, SplitPathCorrectlySplitsRoot) {
	const std::string root_path = "/";

	PathParts parts = SplitPath(root_path);

	EXPECT_EQ(1, parts.size());
	EXPECT_EQ("/", parts[0]);
	}

	// SplitPath correctly splits a standalone directory.
	TEST_F(SmbProviderHelperTest, SplitPathCorrectlySplitsDirPath) {
	const std::string dir_path = "/foo";

	PathParts parts = SplitPath(dir_path);

	EXPECT_EQ(2, parts.size());
	EXPECT_EQ("/", parts[0]);
	EXPECT_EQ("foo", parts[1]);
	}

	// RemoveUrlScheme correctly removes the SMB Url scheme from an SMB Url.
	TEST_F(SmbProviderHelperTest, RemoveUrlSchemeCorrectlyRemovesUrl) {
	EXPECT_EQ("/testShare/dogs", RemoveURLScheme("smb://testShare/dogs"));
	}

	// GetFileName correctly returns root when passed "smb://".
	TEST_F(SmbProviderHelperTest, GetFileNameReturnsRoot) {
	const std::string full_path = "smb://";

	EXPECT_EQ("/", GetFileName(full_path));
	}

	// GetFileName correctly returns the filename when passed "smb://foo".
	TEST_F(SmbProviderHelperTest, GetFileNameReturnsFileNameOnSingleDepth) {
	const std::string full_path = "smb://foo";

	EXPECT_EQ("foo", GetFileName(full_path));
	}

	// GetFileName correctly returns the filename from an SMB Url.
	TEST_F(SmbProviderHelperTest, GetFileNameReturnsFileName) {
	const std::string full_path = "smb://testShare/dogs/lab.jpg";

	EXPECT_EQ("lab.jpg", GetFileName(full_path));
	}

	// GetDirPath correctly returns root when passed "smb://".
	TEST_F(SmbProviderHelperTest, GetDirPathReturnsRoot) {
	const std::string full_path = "smb://";

	EXPECT_EQ("/", GetDirPath(full_path));
	}

	// GetDirPath correctly returns the dirpath when passed "smb://foo".
	TEST_F(SmbProviderHelperTest, GetDirPathReturnsRootOnSingleDepth) {
	const std::string full_path = "smb://foo";

	EXPECT_EQ("/", GetDirPath(full_path));
	}

	// GetDirPath correctly returns the dirpath from an SMB Url.
	TEST_F(SmbProviderHelperTest, GetDirPathReturnsParent) {
	const std::string full_path = "smb://testShare/dogs/lab.jpg";

	EXPECT_EQ("/testShare/dogs", GetDirPath(full_path));
	}

	TEST_F(SmbProviderHelperTest, ShouldReportCreateDirError) {
	EXPECT_FALSE(
	ShouldReportCreateDirError(0 /* result /, false / ignore_existing */));
	EXPECT_FALSE(
	ShouldReportCreateDirError(0 /* result /, true / ignore_existing */));
	EXPECT_FALSE(ShouldReportCreateDirError(EEXIST, true /* ignore_existing */));
	EXPECT_TRUE(ShouldReportCreateDirError(EEXIST, false /* ignore_existing */));
	EXPECT_TRUE(ShouldReportCreateDirError(EPERM, false /* ignore_existing */));
	EXPECT_TRUE(ShouldReportCreateDirError(EPERM, true /* ignore_existing */));
	}

	// GetOpenFilePermissions correctly returns permissions.
	TEST_F(SmbProviderHelperTest, GetOpenFilePermissions) {
	OpenFileOptionsProto open_file_proto_read = CreateOpenFileOptionsProto(
	3 /* mount_id /, "smb://testShare/dir1/pic.png", false / writeable */);
	EXPECT_EQ(O_RDONLY, GetOpenFilePermissions(open_file_proto_read));

	OpenFileOptionsProto open_file_proto_read_write = CreateOpenFileOptionsProto(
	3 /* mount_id /, "smb://testShare/dir1/pic.png", true / writeable */);
	EXPECT_EQ(O_RDWR, GetOpenFilePermissions(open_file_proto_read_write));

	TruncateOptionsProto truncate_proto_blank;
	EXPECT_EQ(O_WRONLY, GetOpenFilePermissions(truncate_proto_blank));

	CopyEntryOptionsProto copy_entry_proto_blank;
	EXPECT_EQ(O_RDONLY, GetOpenFilePermissions(copy_entry_proto_blank));
	}

	TEST_F(SmbProviderHelperTest, GetOpenFilePermissionsBoolean) {
	EXPECT_EQ(O_RDWR, GetOpenFilePermissions(true));

	EXPECT_EQ(O_RDONLY, GetOpenFilePermissions(false));
	}

	namespace {

	std::string ToString(ErrorType error) {
	std::ostringstream out;
	out << error;
	return out.str();
	}

	} // namespace

	TEST_F(SmbProviderHelperTest, ErrorTypeOutputOperator) {
	EXPECT_EQ(ToString(ERROR_NONE), "ERROR_NONE");
	EXPECT_EQ(ToString(ERROR_OK), "ERROR_OK");
	EXPECT_EQ(ToString(ERROR_FAILED), "ERROR_FAILED");
	EXPECT_EQ(ToString(ERROR_IN_USE), "ERROR_IN_USE");
	EXPECT_EQ(ToString(ERROR_EXISTS), "ERROR_EXISTS");
	EXPECT_EQ(ToString(ERROR_NOT_FOUND), "ERROR_NOT_FOUND");
	EXPECT_EQ(ToString(ERROR_ACCESS_DENIED), "ERROR_ACCESS_DENIED");
	EXPECT_EQ(ToString(ERROR_TOO_MANY_OPENED), "ERROR_TOO_MANY_OPENED");
	EXPECT_EQ(ToString(ERROR_NO_MEMORY), "ERROR_NO_MEMORY");
	EXPECT_EQ(ToString(ERROR_NO_SPACE), "ERROR_NO_SPACE");
	EXPECT_EQ(ToString(ERROR_NOT_A_DIRECTORY), "ERROR_NOT_A_DIRECTORY");
	EXPECT_EQ(ToString(ERROR_INVALID_OPERATION), "ERROR_INVALID_OPERATION");
	EXPECT_EQ(ToString(ERROR_SECURITY), "ERROR_SECURITY");
	EXPECT_EQ(ToString(ERROR_ABORT), "ERROR_ABORT");
	EXPECT_EQ(ToString(ERROR_NOT_A_FILE), "ERROR_NOT_A_FILE");
	EXPECT_EQ(ToString(ERROR_NOT_EMPTY), "ERROR_NOT_EMPTY");
	EXPECT_EQ(ToString(ERROR_INVALID_URL), "ERROR_INVALID_URL");
	EXPECT_EQ(ToString(ERROR_IO), "ERROR_IO");
	EXPECT_EQ(ToString(ERROR_PROVIDER_ERROR_COUNT), "ERROR_PROVIDER_ERROR_COUNT");
	EXPECT_EQ(ToString(ERROR_DBUS_PARSE_FAILED), "ERROR_DBUS_PARSE_FAILED");
	EXPECT_EQ(ToString(ERROR_COPY_PENDING), "ERROR_COPY_PENDING");
	EXPECT_EQ(ToString(ERROR_COPY_FAILED), "ERROR_COPY_FAILED");
	EXPECT_EQ(ToString(ERROR_SMB1_UNSUPPORTED), "ERROR_SMB1_UNSUPPORTED");
	EXPECT_EQ(ToString(ERROR_OPERATION_PENDING), "ERROR_OPERATION_PENDING");
	EXPECT_EQ(ToString(ERROR_OPERATION_FAILED), "ERROR_OPERATION_FAILED");
	EXPECT_EQ(ToString(ErrorType(987654)), "ERROR_987654");
	}

	} // namespace smbprovider