[Support] Add support for getting file system permissions on Windows and implement sys::fs::set/getPermissions to work with them

[jhenderson]

Summary

This change adds support for functions to set and get file permissions, in a similar manner to the C++17 permissions() function in <filesystem>. The setter uses chmod on Unix systems and SetFileAttributes on Windows, setting the permissions as passed in. The getter simply uses the existing status() function.

Prior to this change, status() would always return an unknown value for the permissions on a Windows file, making it impossible to test the new function on Windows. I have therefore added support for this as well. On Linux, prior to this change, the permissions included the file type, which should actually be accessed via a different member of the file_status class.

Note that on Windows, only the *_write permission bits have any affect - if any are set, the file is writable, and if not, the file is read-only. This is in common with what MSDN describes for their behaviour of std::filesystem::permissions(), and also what boost::filesystem does.

The motivation behind this change is so that we can easily test behaviour on read-only files in LLVM unit tests, but I am sure that others may find it useful in some situations.

[jhenderson]

Upload correct diff.

[labath]

Sounds reasonable to me, but I'd wait for others' opinion.

lib/Support/Windows/Path.inc

598 ↗

(On Diff #91009)

widenPath already accepts a Twine. No need to convert to a StringRef.

[zturner]

include/llvm/Support/FileSystem.h

573 ↗

(On Diff #91009)

This is called permissions which makes it sound like a getter, not a setter. If you want this to *set* the file permissions you should make it explicit (i.e. set_permissions). That said, you might as well leave this function around as a getter for the permissions, but it should be trivially implementable in Path.cpp as status followed by return st.perms();.

lib/Support/Windows/Path.inc

532–534 ↗

(On Diff #91009)

Is it worth checking whether a file is an exe or batch file before deciding to put all_exe in it? (I don't have a strong opinion, just a thought).

603 ↗

(On Diff #91009)

Isn't owner_write and group_write a subset of all_write? No need to specify all 3 of them as the entire expression just reduces to all_write.

[amccarth]

lib/Support/Windows/Path.inc

601 ↗

(On Diff #91009)

I think you should start with the current file attributes and then add or clear bits as needed. Changing the permissions should not clobber the archive flag, the indexing flag, the hidden flag, or the temporary flag or any other flags that appear in future versions of Windows.

[aaron.ballman]

My biggest concern with this is that it doesn't really set the file permissions on Windows, it just sets the file *attributes*. It's perfectly cromulent for a file to have the read-only attribute set but still not have read permissions for the current user, or to not have the read-only attribute set and still not be writable for the current user, for instance. Is that something we should be caring about?

lib/Support/Windows/Path.inc

532–534 ↗

(On Diff #91009)

I have a slight preference for that, with a FIXME for the more esoteric executable file formats, should anyone ever care about those.

[zturner]

In D30736#696310, @aaron.ballman wrote:

My biggest concern with this is that it doesn't really set the file permissions on Windows, it just sets the file *attributes*. It's perfectly cromulent for a file to have the read-only attribute set but still not have read permissions for the current user, or to not have the read-only attribute set and still not be writable for the current user, for instance. Is that something we should be caring about?

To be fair, to actually implement this as setting the permissions would be a huge effort and involve messing with ACLs and all kinds of other nonsense that just seems completely unnecessary, especially when the only real motivation is to test the behavior of read-only files (which would probably double as a reasonably effective test for the case where you don't have actual permissions to write the file either).

The author points out that the behavior here is consistent with std::filesystem and boost::filesystem, so it seems reasonable here.

lib/Support/Windows/Path.inc

532–534 ↗

(On Diff #91009)

The only reason my preference is slight instead of strong is because you can actually execute anything that has a ShellExecute handler installed. On the other hand, I don't think we need to solve all the world's problems, just LLVM's. And I think we only care about EXEs :)

[aaron.ballman]

In D30736#696314, @zturner wrote:

In D30736#696310, @aaron.ballman wrote:

My biggest concern with this is that it doesn't really set the file permissions on Windows, it just sets the file *attributes*. It's perfectly cromulent for a file to have the read-only attribute set but still not have read permissions for the current user, or to not have the read-only attribute set and still not be writable for the current user, for instance. Is that something we should be caring about?

To be fair, to actually implement this as setting the permissions would be a huge effort and involve messing with ACLs and all kinds of other nonsense that just seems completely unnecessary, especially when the only real motivation is to test the behavior of read-only files (which would probably double as a reasonably effective test for the case where you don't have actual permissions to write the file either).

Yeah, that's why I was asking how much we cared. ;-)

The author points out that the behavior here is consistent with std::filesystem and boost::filesystem, so it seems reasonable here.

Ah, I missed that this was consistent with std::filesystem, which is plenty to convince me.

[jhenderson]

Just for the sake of clarity, I've only compared against the documented behaviour of std::filesystem on MSDN, rather than the actual behaviour. I've tried using std::experimental::filesystem (I don't have a version of MSVC with std::filesystem yet), and it does exhibit the behaviour described in the documentation, as far as I can observe, i.e. any write bit marks the file as read-only, otherwise the file is marked as writable, and all other permission bits are ignored. I don't know how to check the varying levels of owner/group/others at this point, but I see no reason to disbelieve the documentation.

I'll work on the various other improvements as suggested now and will update the patch.

Thanks all.

include/llvm/Support/FileSystem.h

573 ↗

(On Diff #91009)

I did consider doing this (indeed my first implementation called it set_file_permissions), but I went with permissions, to match the std::filesystem function. I will add the getter regardless, as it makes sense.

lib/Support/Windows/Path.inc

532–534 ↗

(On Diff #91009)

Doing this for an .exe (or indeed any executable that is actually a program rather than a script without regards to the file extension) is certainly possible using GetBinaryType. I'm not sure if there's any way of doing this for batch files other than inspecting the file extension, but I guess that is what Windows does itself.

As with other behaviour regarding the permissions bits, the argument for not doing this is because the *exe permission bit is completely ignored by Windows, according to the MSDN documentation on std::filesystem. Thus, using status() would yield different permissions to the std version in the future once it is fully supported. I would think that eventually we could replace this function with std::filesytem::status(), so compatibility is probably important. However, if people are not concerned about this, I will go ahead and implement it that way.

598 ↗

(On Diff #91009)

Thanks, didn't notice that. I was basing my code purely on what the status() function already does.

601 ↗

(On Diff #91009)

Good point. Thanks.

603 ↗

(On Diff #91009)

Oops, that was originally meant to be others_write, rather than all_write, but of course, all_write is entirely sufficient here as you point out.

[jhenderson]

Addressed review comments. I have added a getter as suggested by @zturner and have used that in the unit tests. I have also fixed the various minor points others have pointed out. I haven't renamed the setter function at this point, for the reasons addressed in my inline comments, and I also still always return the all_exe permission for reasons outlined as well.

I haven't been able to come up with a good simple test for checking that the file attributes are not accidentally clobbered. The problem is that to test them, I need to call the Windows Get/SetFileAttributes functions, which require wide paths and the widenPath function is in a private header, so isn't something that can be used in the tests. I don't really know how I'd go about moving that code, since it is completely Windows specific. I did test the behaviour manually.

[amccarth]

I'm happy if the other reviewers are.

[zturner]

Honestly I'm not real happy with the name. It probably seems like a minor point but I'm tempted to just say that STL has it wrong too (it wouldn't be the first time, i.e. vector<bool>). If nobody else feels super strongly I can let it pass, but I would really rather see either get_permissions / set_permissions or permissions / set_permissions in keeping with LLVM traditions.

[jhenderson]

Renamed function. I'm not strongly opposed to this.

[jhenderson]

I chose to rename the functions to get/setPermissions. I noticed that function names in this file are in two different styles, so I had to pick one, so I went with the wider LLVM style, since we are now deliberately NOT matching the std::filesystem function name.

[jhenderson]

Removed spurious #include from unit tests that had snuck in due to unrelated local changes.

[jhenderson]

@zturner or @amccarth, would one of you mind committing this, please? I don't have commit access yet. Also @zturner, your LGTM doesn't seem to be showing up here for some reason...!

[aaron.ballman]

LGTM as well; I've commit in r297617, thank you!

[aaron.ballman]

In D30736#699146, @aaron.ballman wrote:

LGTM as well; I've commit in r297617, thank you!

I had to revert, as this broke at least one of the bots: http://bb.pgr.jp/builders/cmake-llvm-x86_64-linux/builds/49970

[jhenderson]

In D30736#699157, @aaron.ballman wrote:

In D30736#699146, @aaron.ballman wrote:

LGTM as well; I've commit in r297617, thank you!

I had to revert, as this broke at least one of the bots: http://bb.pgr.jp/builders/cmake-llvm-x86_64-linux/builds/49970

I'm just verifying a fix locally, but it turns out the problem is that on Linux, the file type is encoded in the st_mode field of the stat struct, but is not removed when setting the permissions value. As a result, the getter gets a value with the S_IFREG still set. My plan is to remove this bit (and all other file type bits) when the value is set in getStatus, so that the getter only cares about the permissions as defined in the perms enum. I didn't spot the issue previously because I did not realise that the unit tests were not being built on Linux.

[jhenderson]

Fixed Linux unit tests by adding a new member of the perms structure to cover all valid values (except perms_not_known) and using this to mask the Perms member of the file_status struct. This removes the file type from this member, which was probably the original desired behaviour anyway. Users can get the file type from the Type member instead.

[aaron.ballman]

Can someone more familiar with UNIX permissions review the new changes before we land them?

[zturner]

The changes look ok to me. james, did you confirm the tests pass on Linux?

[jhenderson]

In D30736#701833, @zturner wrote:

The changes look ok to me. james, did you confirm the tests pass on Linux?

I did once, but I'll double check. I have commit access now, so can commit this myself once I've done that. Thanks for the help!

llvm/trunk/include/llvm/Support/FileSystem.h

enum perms {
   others_all = others_read | others_write | others_exe,
   all_read = owner_read | group_read | others_read,
   all_write = owner_write | group_write | others_write,
   all_exe = owner_exe | group_exe | others_exe,
   all_all = owner_all | group_all | others_all,
   set_uid_on_exe = 04000,
   set_gid_on_exe = 02000,
   sticky_bit = 01000,
+  all_perms = all_all | set_uid_on_exe | set_gid_on_exe | sticky_bit,
   perms_not_known = 0xFFFF
 };
 
 // Helper functions so that you can use & and | to manipulate perms bits:
 inline perms operator|(perms l, perms r) {
   return static_cast<perms>(static_cast<unsigned short>(l) |
                             static_cast<unsigned short>(r));
 }
file_status(file_type Type, perms Perms, dev_t Dev, ino_t Ino, time_t ATime,
       : fs_st_dev(Dev), fs_st_ino(Ino), fs_st_atime(ATime), fs_st_mtime(MTime),
         fs_st_uid(UID), fs_st_gid(GID), fs_st_size(Size), Type(Type),
         Perms(Perms) {}
   #elif defined(LLVM_ON_WIN32)
   file_status() = default;
 
   file_status(file_type Type) : Type(Type) {}
 
-  file_status(file_type Type, uint32_t LastAccessTimeHigh,
+  file_status(file_type Type, perms Perms, uint32_t LastAccessTimeHigh,
               uint32_t LastAccessTimeLow, uint32_t LastWriteTimeHigh,
               uint32_t LastWriteTimeLow, uint32_t VolumeSerialNumber,
               uint32_t FileSizeHigh, uint32_t FileSizeLow,
               uint32_t FileIndexHigh, uint32_t FileIndexLow)
       : LastAccessedTimeHigh(LastAccessTimeHigh), LastAccessedTimeLow(LastAccessTimeLow),
         LastWriteTimeHigh(LastWriteTimeHigh),
         LastWriteTimeLow(LastWriteTimeLow),
         VolumeSerialNumber(VolumeSerialNumber), FileSizeHigh(FileSizeHigh),
         FileSizeLow(FileSizeLow), FileIndexHigh(FileIndexHigh),
-        FileIndexLow(FileIndexLow), Type(Type) {}
+        FileIndexLow(FileIndexLow), Type(Type), Perms(Perms) {}
   #endif
 
   // getters
   file_type type() const { return Type; }
   perms permissions() const { return Perms; }
   TimePoint<> getLastAccessedTime() const;
   TimePoint<> getLastModificationTime() const;
   UniqueID getUniqueID() const;

 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
 std::error_code status(const Twine &path, file_status &result,
                        bool follow = true);
 
 /// @brief A version for when a file descriptor is already available.
 std::error_code status(int FD, file_status &Result);
 
+/// @brief Set file permissions.
+///
+/// @param Path File to set permissions on.
+/// @param Permissions New file permissions.
+/// @returns errc::success if the permissions were successfully set, otherwise
+///          a platform-specific error_code.
+/// @note On Windows, all permissions except *_write are ignored. Using any of
+///       owner_write, group_write, or all_write will make the file writable.
+///       Otherwise, the file will be marked as read-only.
+std::error_code setPermissions(const Twine &Path, perms Permissions);
+
+/// @brief Get file permissions.
+///
+/// @param Path File to get permissions from.
+/// @returns the permissions if they were successfully retrieved, otherwise a
+///          platform-specific error_code.
+/// @note On Windows, if the file does not have the FILE_ATTRIBUTE_READONLY
+///       attribute, all_all will be returned. Otherwise, all_read | all_exe
+///       will be returned.
+ErrorOr<perms> getPermissions(const Twine &Path);
+
 /// @brief Get file size.
 ///
 /// @param Path Input path.
 /// @param Result Set to the size of the file in \a Path.
 /// @returns errc::success if result has been successfully set, otherwise a
 ///          platform-specific error_code.
 inline std::error_code file_size(const Twine &Path, uint64_t &Result) {
   file_status Status;

llvm/trunk/lib/Support/Path.cpp

std::error_code identify_magic(const Twine &Path, file_magic &Result) {
   Result = identify_magic(StringRef(Buffer, Length));
   return std::error_code();
 }
 
 std::error_code directory_entry::status(file_status &result) const {
   return fs::status(Path, result, FollowSymlinks);
 }
 
+ErrorOr<perms> getPermissions(const Twine &Path) {
+  file_status Status;
+  if (std::error_code EC = status(Path, Status))
+    return EC;
+
+  return Status.permissions();
+}
+
 } // end namespace fs
 } // end namespace sys
 } // end namespace llvm
 
 // Include the truly platform-specific parts.
 #if defined(LLVM_ON_UNIX)
 #include "Unix/Path.inc"
 #endif

llvm/trunk/lib/Support/Unix/Path.inc

else if (S_ISCHR(Status.st_mode))
     Type = file_type::character_file;
   else if (S_ISFIFO(Status.st_mode))
     Type = file_type::fifo_file;
   else if (S_ISSOCK(Status.st_mode))
     Type = file_type::socket_file;
   else if (S_ISLNK(Status.st_mode))
     Type = file_type::symlink_file;
 
-  perms Perms = static_cast<perms>(Status.st_mode);
+  perms Perms = static_cast<perms>(Status.st_mode) & all_perms;
   Result =
       file_status(Type, Perms, Status.st_dev, Status.st_ino, Status.st_atime,
                   Status.st_mtime, Status.st_uid, Status.st_gid,
                   Status.st_size);
 
   return std::error_code();
 }
 
 std::error_code status(const Twine &Path, file_status &Result, bool Follow) {
   SmallString<128> PathStorage;
   StringRef P = Path.toNullTerminatedStringRef(PathStorage);
 
   struct stat Status;
   int StatRet = (Follow ? ::stat : ::lstat)(P.begin(), &Status);
   return fillStatus(StatRet, Status, Result);
 }
 
 std::error_code status(int FD, file_status &Result) {
   struct stat Status;
   int StatRet = ::fstat(FD, &Status);
   return fillStatus(StatRet, Status, Result);
 }
 
+std::error_code setPermissions(const Twine &Path, perms Permissions) {
+  SmallString<128> PathStorage;
+  StringRef P = Path.toNullTerminatedStringRef(PathStorage);
+
+  if (::chmod(P.begin(), Permissions))
+    return std::error_code(errno, std::generic_category());
+  return std::error_code();
+}
+
 std::error_code setLastModificationAndAccessTime(int FD, TimePoint<> Time) {
 #if defined(HAVE_FUTIMENS)
   timespec Times[2];
   Times[0] = Times[1] = sys::toTimeSpec(Time);
   if (::futimens(FD, Times))
     return std::error_code(errno, std::generic_category());
   return std::error_code();
 #elif defined(HAVE_FUTIMES)

llvm/trunk/lib/Support/Windows/Path.inc

static std::error_code getStatus(HANDLE FileHandle, file_status &Result) {
   BY_HANDLE_FILE_INFORMATION Info;
   if (!::GetFileInformationByHandle(FileHandle, &Info))
     goto handle_status_error;
 
   {
     file_type Type = (Info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                          ? file_type::directory_file
                          : file_type::regular_file;
-    Result =
-        file_status(Type, Info.ftLastAccessTime.dwHighDateTime,
-                    Info.ftLastAccessTime.dwLowDateTime,
-                    Info.ftLastWriteTime.dwHighDateTime,
-                    Info.ftLastWriteTime.dwLowDateTime,
-                    Info.dwVolumeSerialNumber, Info.nFileSizeHigh,
-                    Info.nFileSizeLow, Info.nFileIndexHigh, Info.nFileIndexLow);
+    perms Permissions = (Info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
+                            ? (all_read | all_exe)
+                            : all_all;
+    Result = file_status(
+        Type, Permissions, Info.ftLastAccessTime.dwHighDateTime,
+        Info.ftLastWriteTime.dwHighDateTime, Info.ftLastWriteTime.dwLowDateTime,
+        Info.dwVolumeSerialNumber, Info.nFileSizeHigh, Info.nFileSizeLow,
+        Info.nFileIndexHigh, Info.nFileIndexLow);
     return std::error_code();
   }
 
 handle_status_error:
   DWORD LastError = ::GetLastError();
   if (LastError == ERROR_FILE_NOT_FOUND ||
       LastError == ERROR_PATH_NOT_FOUND)
     Result = file_status(file_type::file_not_found);
std::error_code status(const Twine &path, file_status &result, bool Follow) {
   return getStatus(h, result);
 }
 
 std::error_code status(int FD, file_status &Result) {
   HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
   return getStatus(FileHandle, Result);
 }
 
+std::error_code setPermissions(const Twine &Path, perms Permissions) {
+  SmallVector<wchar_t, 128> PathUTF16;
+  if (std::error_code EC = widenPath(Path, PathUTF16))
+    return EC;
+
+  DWORD Attributes = ::GetFileAttributesW(PathUTF16.begin());
+  if (Attributes == INVALID_FILE_ATTRIBUTES)
+    return mapWindowsError(GetLastError());
+
+  // There are many Windows file attributes that are not to do with the file
+  // permissions (e.g. FILE_ATTRIBUTE_HIDDEN). We need to be careful to preserve
+  // them.
+  if (Permissions & all_write) {
+    Attributes &= ~FILE_ATTRIBUTE_READONLY;
+    if (Attributes == 0)
+      // FILE_ATTRIBUTE_NORMAL indicates no other attributes are set.
+      Attributes |= FILE_ATTRIBUTE_NORMAL;
+  }
+  else {
+    Attributes |= FILE_ATTRIBUTE_READONLY;
+    // FILE_ATTRIBUTE_NORMAL is not compatible with any other attributes, so
+    // remove it, if it is present.
+    Attributes &= ~FILE_ATTRIBUTE_NORMAL;
+  }
+
+  if (!::SetFileAttributesW(PathUTF16.begin(), Attributes))
+    return mapWindowsError(GetLastError());
+
+  return std::error_code();
+}
+
 std::error_code setLastModificationAndAccessTime(int FD, TimePoint<> Time) {
   FILETIME FT = toFILETIME(Time);
   HANDLE FileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
   if (!SetFileTime(FileHandle, NULL, &FT, &FT))
     return mapWindowsError(::GetLastError());
   return std::error_code();
 }
 

llvm/trunk/unittests/Support/Path.cpp

TEST_F(FileSystemTest, set_current_path) {
   ASSERT_NO_ERROR(fs::current_path(path));
 
   fs::UniqueID D1, D2;
   ASSERT_NO_ERROR(fs::getUniqueID(TestDirectory, D1));
   ASSERT_NO_ERROR(fs::getUniqueID(path, D2));
   ASSERT_EQ(D1, D2) << "D1: " << TestDirectory << "\nD2: " << path;
 }
 
+TEST_F(FileSystemTest, permissions) {
+  int FD;
+  SmallString<64> TempPath;
+  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));
+  FileRemover Cleanup(TempPath);
+
+  // Make sure it exists.
+  ASSERT_TRUE(fs::exists(Twine(TempPath)));
+
+  auto CheckPermissions = [&](fs::perms Expected) {
+    ErrorOr<fs::perms> Actual = fs::getPermissions(TempPath);
+    return Actual && *Actual == Expected;
+  };
+
+  std::error_code NoError;
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_all), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::all_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_read | fs::all_exe));
+
+#if defined(LLVM_ON_WIN32)
+  fs::perms ReadOnly = fs::all_read | fs::all_exe;
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::no_perms), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_read), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_write), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_all), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_read), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_write), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_all), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_read), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_write), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_all), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_write), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_gid_on_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::sticky_bit), NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe |
+                                             fs::set_gid_on_exe |
+                                             fs::sticky_bit),
+            NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, ReadOnly | fs::set_uid_on_exe |
+                                             fs::set_gid_on_exe |
+                                             fs::sticky_bit),
+            NoError);
+  EXPECT_TRUE(CheckPermissions(ReadOnly));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_all));
+#else
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::no_perms), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::no_perms));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_read), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::owner_read));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_write), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::owner_write));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::owner_exe));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_all), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::owner_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_read), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::group_read));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_write), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::group_write));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::group_exe));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_all), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::group_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_read), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::others_read));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_write), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::others_write));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::others_exe));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_all), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::others_all));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_read));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_write), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_write));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_exe));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_gid_on_exe), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::set_gid_on_exe));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::sticky_bit), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::sticky_bit));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe |
+                                             fs::set_gid_on_exe |
+                                             fs::sticky_bit),
+            NoError);
+  EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe | fs::set_gid_on_exe |
+                               fs::sticky_bit));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::set_uid_on_exe |
+                                             fs::set_gid_on_exe |
+                                             fs::sticky_bit),
+            NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_read | fs::set_uid_on_exe |
+                               fs::set_gid_on_exe | fs::sticky_bit));
+
+  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms), NoError);
+  EXPECT_TRUE(CheckPermissions(fs::all_perms));
+#endif
+}
+
 } // anonymous namespace