| //===- llvm/unittest/Support/ReplaceFileTest.cpp - unit tests -------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/Support/Errc.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include "llvm/Support/FileSystem.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "llvm/Support/Path.h" |
| #include "llvm/Support/Process.h" |
| #include "gtest/gtest.h" |
| |
| using namespace llvm; |
| using namespace llvm::sys; |
| |
| #define ASSERT_NO_ERROR(x) \ |
| do { \ |
| if (std::error_code ASSERT_NO_ERROR_ec = x) { \ |
| errs() << #x ": did not return errc::success.\n" \ |
| << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n" \ |
| << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n"; \ |
| } \ |
| } while (false) |
| |
| namespace { |
| std::error_code CreateFileWithContent(const SmallString<128> &FilePath, |
| const StringRef &content) { |
| int FD = 0; |
| if (std::error_code ec = fs::openFileForWrite(FilePath, FD)) |
| return ec; |
| |
| const bool ShouldClose = true; |
| raw_fd_ostream OS(FD, ShouldClose); |
| OS << content; |
| |
| return std::error_code(); |
| } |
| |
| class ScopedFD { |
| int FD; |
| |
| ScopedFD(const ScopedFD &) = delete; |
| ScopedFD &operator=(const ScopedFD &) = delete; |
| |
| public: |
| explicit ScopedFD(int Descriptor) : FD(Descriptor) {} |
| ~ScopedFD() { Process::SafelyCloseFileDescriptor(FD); } |
| }; |
| |
| bool FDHasContent(int FD, StringRef Content) { |
| auto Buffer = |
| MemoryBuffer::getOpenFile(sys::fs::convertFDToNativeFile(FD), "", -1); |
| assert(Buffer); |
| return Buffer.get()->getBuffer() == Content; |
| } |
| |
| bool FileHasContent(StringRef File, StringRef Content) { |
| int FD = 0; |
| auto EC = fs::openFileForRead(File, FD); |
| (void)EC; |
| assert(!EC); |
| ScopedFD EventuallyCloseIt(FD); |
| return FDHasContent(FD, Content); |
| } |
| |
| TEST(rename, FileOpenedForReadingCanBeReplaced) { |
| // Create unique temporary directory for this test. |
| SmallString<128> TestDirectory; |
| ASSERT_NO_ERROR(fs::createUniqueDirectory( |
| "FileOpenedForReadingCanBeReplaced-test", TestDirectory)); |
| |
| // Add a couple of files to the test directory. |
| SmallString<128> SourceFileName(TestDirectory); |
| path::append(SourceFileName, "source"); |
| |
| SmallString<128> TargetFileName(TestDirectory); |
| path::append(TargetFileName, "target"); |
| |
| ASSERT_NO_ERROR(CreateFileWithContent(SourceFileName, "!!source!!")); |
| ASSERT_NO_ERROR(CreateFileWithContent(TargetFileName, "!!target!!")); |
| |
| { |
| // Open the target file for reading. |
| int ReadFD = 0; |
| ASSERT_NO_ERROR(fs::openFileForRead(TargetFileName, ReadFD)); |
| ScopedFD EventuallyCloseIt(ReadFD); |
| |
| // Confirm we can replace the file while it is open. |
| EXPECT_TRUE(!fs::rename(SourceFileName, TargetFileName)); |
| |
| // We should still be able to read the old data through the existing |
| // descriptor. |
| EXPECT_TRUE(FDHasContent(ReadFD, "!!target!!")); |
| |
| // The source file should no longer exist |
| EXPECT_FALSE(fs::exists(SourceFileName)); |
| } |
| |
| // If we obtain a new descriptor for the target file, we should find that it |
| // contains the content that was in the source file. |
| EXPECT_TRUE(FileHasContent(TargetFileName, "!!source!!")); |
| |
| // Rename the target file back to the source file name to confirm that rename |
| // still works if the destination does not already exist. |
| EXPECT_TRUE(!fs::rename(TargetFileName, SourceFileName)); |
| EXPECT_FALSE(fs::exists(TargetFileName)); |
| ASSERT_TRUE(fs::exists(SourceFileName)); |
| |
| // Clean up. |
| ASSERT_NO_ERROR(fs::remove(SourceFileName)); |
| ASSERT_NO_ERROR(fs::remove(TestDirectory.str())); |
| } |
| |
| TEST(rename, ExistingTemp) { |
| // Test that existing .tmpN files don't get deleted by the Windows |
| // sys::fs::rename implementation. |
| SmallString<128> TestDirectory; |
| ASSERT_NO_ERROR( |
| fs::createUniqueDirectory("ExistingTemp-test", TestDirectory)); |
| |
| SmallString<128> SourceFileName(TestDirectory); |
| path::append(SourceFileName, "source"); |
| |
| SmallString<128> TargetFileName(TestDirectory); |
| path::append(TargetFileName, "target"); |
| |
| SmallString<128> TargetTmp0FileName(TestDirectory); |
| path::append(TargetTmp0FileName, "target.tmp0"); |
| |
| SmallString<128> TargetTmp1FileName(TestDirectory); |
| path::append(TargetTmp1FileName, "target.tmp1"); |
| |
| ASSERT_NO_ERROR(CreateFileWithContent(SourceFileName, "!!source!!")); |
| ASSERT_NO_ERROR(CreateFileWithContent(TargetFileName, "!!target!!")); |
| ASSERT_NO_ERROR(CreateFileWithContent(TargetTmp0FileName, "!!target.tmp0!!")); |
| |
| { |
| // Use mapped_file_region to make sure that the destination file is mmap'ed. |
| // This will cause SetInformationByHandle to fail when renaming to the |
| // destination, and we will follow the code path that tries to give target |
| // a temporary name. |
| int TargetFD; |
| std::error_code EC; |
| ASSERT_NO_ERROR(fs::openFileForRead(TargetFileName, TargetFD)); |
| ScopedFD X(TargetFD); |
| sys::fs::mapped_file_region MFR(sys::fs::convertFDToNativeFile(TargetFD), |
| sys::fs::mapped_file_region::readonly, 10, |
| 0, EC); |
| ASSERT_FALSE(EC); |
| |
| ASSERT_NO_ERROR(fs::rename(SourceFileName, TargetFileName)); |
| |
| #ifdef _WIN32 |
| // Make sure that target was temporarily renamed to target.tmp1 on Windows. |
| // This is signified by a permission denied error as opposed to no such file |
| // or directory when trying to open it. |
| int Tmp1FD; |
| EXPECT_EQ(errc::permission_denied, |
| fs::openFileForRead(TargetTmp1FileName, Tmp1FD)); |
| #endif |
| } |
| |
| EXPECT_TRUE(FileHasContent(TargetTmp0FileName, "!!target.tmp0!!")); |
| |
| ASSERT_NO_ERROR(fs::remove(TargetFileName)); |
| ASSERT_NO_ERROR(fs::remove(TargetTmp0FileName)); |
| ASSERT_NO_ERROR(fs::remove(TestDirectory.str())); |
| } |
| |
| } // anonymous namespace |