public void CreateDirectoryNested()
{
string Target = PathGeneratorUtilities.GetRelativePath("parentDir", "targetDir");
FileUtilities.CreateDirectory(GetFullPath(Target));
XAssert.IsTrue(Directory.Exists(GetFullPath(Target)));
}
public void CreateHardlinkSupportsLongPath()
{
var longPath = Enumerable.Range(0, NativeIOConstants.MaxDirectoryPath).Aggregate(TemporaryDirectory, (path, _) => Path.Combine(path, "dir"));
FileUtilities.CreateDirectory(longPath);
var file = Path.Combine(longPath, "out.txt");
var link = Path.Combine(longPath, "hardlink");
SafeFileHandle fileHandle;
var result = FileUtilities.TryCreateOrOpenFile(
file,
FileDesiredAccess.GenericWrite,
FileShare.Delete,
FileMode.Create,
FileFlagsAndAttributes.FileAttributeNormal,
out fileHandle);
XAssert.IsTrue(result.Succeeded);
using (FileStream stream = new FileStream(fileHandle, FileAccess.Write))
{
stream.WriteByte(255);
}
XAssert.IsTrue(CreateHardLinkIfSupported(link: link, linkTarget: file));
}
public void TestEnumerateFilesWithPattern()
{
const string Target = "targetDir";
string nestedDirectory = GetFullPath(Path.Combine(Target, "sub1", "sub2", "sub3"));
FileUtilities.CreateDirectory(nestedDirectory);
const string Content = "my text";
File.WriteAllText(Path.Combine(nestedDirectory, "sub_file.txt"), Content);
var entries = FileUtilities.FileSystem.EnumerateFiles(GetFullPath(Target), pattern: "sub*", recursive: true);
XAssert.SetEqual(new [] { "sub_file.txt" }, entries.Select(e => e.FileName).ToHashSet());
// Checking the size of the file.
XAssert.AreEqual(Content.Length, entries.First(e => e.FileName == "sub_file.txt").Size);
XAssert.AreEqual(0, FileUtilities.FileSystem.EnumerateFiles(GetFullPath(Target), pattern: "sub1", recursive: true).Count);
XAssert.AreEqual(1, FileUtilities.FileSystem.EnumerateFiles(GetFullPath(Target), pattern: "sub_file*", recursive: true).Count);
XAssert.AreEqual(1, FileUtilities.FileSystem.EnumerateFiles(GetFullPath(Target), pattern: "*.txt", recursive: true).Count);
// Non recursive case
XAssert.AreEqual(0, FileUtilities.FileSystem.EnumerateFiles(GetFullPath(Target), pattern: "*.txt", recursive: false).Count);
// Pattern with 0 matches
XAssert.AreEqual(0, FileUtilities.FileSystem.EnumerateFiles(GetFullPath(Target), pattern: "foo", recursive: true).Count);
}
public void CreateDirectory()
{
const string Target = "targetDir";
FileUtilities.CreateDirectory(GetFullPath(Target));
XAssert.IsTrue(Directory.Exists(GetFullPath(Target)));
FileUtilities.CreateDirectory(GetFullPath(Target));
XAssert.IsTrue(Directory.Exists(GetFullPath(Target)));
}
private void VerifyResolveSymlink(string symlinkPath, string target, string expectedResult)
{
FileUtilities.CreateDirectory(Path.GetDirectoryName(symlinkPath));
XAssert.PossiblySucceeded(FileUtilities.TryCreateSymbolicLink(symlinkPath, target, isTargetFile: true));
var maybeResult = FileUtilities.ResolveSymlinkTarget(symlinkPath, target);
if (expectedResult != null)
{
XAssert.IsTrue(maybeResult.Succeeded, maybeResult.Succeeded ? string.Empty : maybeResult.Failure.DescribeIncludingInnerFailures());
XAssert.ArePathEqual(expectedResult, maybeResult.Result);
}
else
{
XAssert.IsFalse(maybeResult.Succeeded);
}
}
[Trait("Category", "WindowsOSOnly")] // TODO: Fix for non Windows
public void GetChainOfSymlinksWithDirectorySymlink()
{
// File and directory layout:
// Enlist
// |
// +---Intermediate
// | \---Current
// | file.lnk ==> ..\..\Target\file.txt
// |
// +---Source ==> Intermediate\Current
// |
// \---Target
// file.txt
// Create a concrete file /Target/file.txt
string targetFile = GetFullPath(R("Target", "file.txt"));
FileUtilities.CreateDirectory(Path.GetDirectoryName(targetFile));
File.WriteAllText(targetFile, "Contents");
// Create a symlink /Intermediate/Current/file.lnk --> ../../Target/file.txt
string intermediateLink = GetFullPath(R("Intermediate", "Current", "file.lnk"));
FileUtilities.CreateDirectory(Path.GetDirectoryName(intermediateLink));
XAssert.PossiblySucceeded(FileUtilities.TryCreateSymbolicLink(intermediateLink, R("..", "..", "Target", "file.txt"), isTargetFile: true));
// Create a directory symlink /Source --> Intermediate/Current
// Access /Source/file.lnk.
string sourceLink = GetFullPath(R("Source", "file.lnk"));
XAssert.PossiblySucceeded(FileUtilities.TryCreateSymbolicLink(Path.GetDirectoryName(sourceLink), R("Intermediate", "Current"), isTargetFile: false));
using (SafeFileHandle handle = OpenHandleForReparsePoint(sourceLink))
{
var chain = new List <string>();
FileUtilities.GetChainOfReparsePoints(handle, sourceLink, chain);
// There are two ways of reaching file.lnk, (1) /Source/file.lnk, and (2) /Intermediate/Current/file.lnk.
// For Windows, BuildXL does not track all possible paths reaching to file.lnk; only what the tool/user accesses.
// In this case, we access /Source/file.lnk. Thus, only /Source/file.lnk and /Target/file.txt are in the chain.
// TODO: Reconcile this with Mac implementation.
XAssert.AreEqual(2, chain.Count, "Chain of reparse points: " + string.Join(" -> ", chain));
XAssert.ArePathEqual(sourceLink, TrimPathPrefix(chain[0]));
XAssert.ArePathEqual(targetFile, TrimPathPrefix(chain[1]));
}
}
public void LongPathAccessControlTest()
{
var longPath = Enumerable.Range(0, NativeIOConstants.MaxDirectoryPath).Aggregate(TemporaryDirectory, (path, _) => Path.Combine(path, "dir"));
var file = Path.Combine(longPath, "fileWithWriteAccess.txt");
FileUtilities.CreateDirectory(longPath);
SafeFileHandle fileHandle;
var result = FileUtilities.TryCreateOrOpenFile(
file,
FileDesiredAccess.GenericWrite,
FileShare.Delete,
FileMode.Create,
FileFlagsAndAttributes.FileAttributeNormal,
out fileHandle);
XAssert.IsTrue(result.Succeeded);
FileUtilities.SetFileAccessControl(file, FileSystemRights.WriteAttributes, true);
XAssert.IsTrue(FileUtilities.HasWritableAccessControl(file));
//Delete the created directory
fileHandle.Close();
FileUtilities.DeleteDirectoryContents(longPath, deleteRootDirectory: true);
}
public void TestResolveSymlinkWithDirectorySymlinkOrJunction(bool useJunction, bool oneDotDot)
{
// File and directory layout:
// Enlist
// |
// +---Intermediate
// | \---Current
// | file.lnk ==> ..\..\Target\file.txt (or ..\Target\file.txt)
// |
// +---Source ==> Intermediate\Current
// |
// \---Target
// file.txt
// Create a symlink Enlist/Intermediate/Current/file.lnk --> ../../Target/file.txt (or ../Target/file.txt)
string symlinkFile = GetFullPath(R("Enlist", "Intermediate", "Current", "file.lnk"));
FileUtilities.CreateDirectory(GetFullPath(R("Enlist", "Intermediate", "Current")));
var relativeTarget = oneDotDot ? R("..", "Target", "file.txt") : R("..", "..", "Target", "file.txt");
XAssert.PossiblySucceeded(FileUtilities.TryCreateSymbolicLink(symlinkFile, relativeTarget, isTargetFile: true));
// Create a directory symlink Enlist/Source --> Enlist/Intermediate/Current
string symlinkDirectory = GetFullPath(R("Enlist", "Source"));
if (useJunction)
{
FileUtilities.CreateDirectory(symlinkDirectory);
FileUtilities.CreateJunction(symlinkDirectory, GetFullPath(R("Enlist", "Intermediate", "Current")));
}
else
{
XAssert.PossiblySucceeded(FileUtilities.TryCreateSymbolicLink(symlinkDirectory, R("Intermediate", "Current"), isTargetFile: false));
}
string expectedFinalPath = null;
if (useJunction)
{
expectedFinalPath = oneDotDot ? GetFullPath(R("Enlist", "Target", "file.txt")) : GetFullPath(R("Target", "file.txt"));
}
else
{
expectedFinalPath = oneDotDot ? GetFullPath(R("Enlist", "Intermediate", "Target", "file.txt")) : GetFullPath(R("Enlist", "Target", "file.txt"));
}
// Resolve symlink Enlist/Source/file.lnk by supplying the symlink relative target path (../../Target/file.txt or ../Target/file.txt).
var maybeResult = FileUtilities.ResolveSymlinkTarget(GetFullPath(R("Enlist", "Source", "file.lnk")), relativeTarget);
XAssert.PossiblySucceeded(maybeResult);
XAssert.ArePathEqual(expectedFinalPath, maybeResult.Result);
// Resolve symlink Enlist/Source/file.lnk without supplying the symlink target path
// The result should be Enlist/Target/file.txt
maybeResult = FileUtilities.ResolveSymlinkTarget(GetFullPath(R("Enlist", "Source", "file.lnk")));
XAssert.PossiblySucceeded(maybeResult);
XAssert.ArePathEqual(expectedFinalPath, maybeResult.Result);
}
