private void AlphaFS_File_GetProcessForFileLock_NoLockReturnsNull(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]\n", file.FullName);
Assert.IsNull(Alphaleonis.Win32.Filesystem.File.GetProcessForFileLock(file.FullName));
}
}
private void AlphaFS_File_Move_DelayUntilReboot(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var pendingEntry = tempRoot.CreateFile();
var fileLength = pendingEntry.Length;
Console.WriteLine("Src File Path: [{0}]", pendingEntry.FullName);
if (isNetwork)
{
UnitTestAssert.ThrowsException <ArgumentException>(() => Alphaleonis.Win32.Filesystem.File.Move(pendingEntry.FullName, null, Alphaleonis.Win32.Filesystem.MoveOptions.DelayUntilReboot));
}
else
{
var moveResult = Alphaleonis.Win32.Filesystem.File.Move(pendingEntry.FullName, null, Alphaleonis.Win32.Filesystem.MoveOptions.DelayUntilReboot);
UnitTestConstants.Dump(moveResult);
UnitTestAssert.RegistryContainsPendingEntry(pendingEntry.FullName);
// Test against moveResult results.
Assert.IsFalse(moveResult.IsCopy);
Assert.IsTrue(moveResult.IsMove);
Assert.IsFalse(moveResult.IsDirectory);
Assert.IsTrue(moveResult.IsFile);
Assert.AreEqual(1, moveResult.TotalFiles);
Assert.AreEqual(0, moveResult.TotalFolders);
Assert.AreEqual(fileLength, moveResult.TotalBytes);
Assert.IsNull(moveResult.Destination);
Assert.IsTrue(System.IO.File.Exists(pendingEntry.FullName), "The file does not exists, but it is expected.");
}
}
Console.WriteLine();
}
private void File_Exists_ExistingFile(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
Assert.IsTrue(Alphaleonis.Win32.Filesystem.File.Exists(file.FullName), "The file does not exists, but is expected to.");
}
Console.WriteLine();
}
private void FileInfo_InitializeInstance_ExistingFile(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
var alphaFSFileInfo = new Alphaleonis.Win32.Filesystem.FileInfo(file.FullName);
using (file.Create())
CompareFileInfos(file, alphaFSFileInfo, true);
}
Console.WriteLine();
}
private void AlphaFS_File_GetChangeTime(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var notepadFile = System.IO.Path.Combine(Environment.SystemDirectory, "notepad.exe");
Console.WriteLine("Input File Path: [{0}]", notepadFile);
Assert.AreEqual(System.IO.File.GetCreationTime(notepadFile), Alphaleonis.Win32.Filesystem.File.GetCreationTime(notepadFile));
Assert.AreEqual(System.IO.File.GetCreationTimeUtc(notepadFile), Alphaleonis.Win32.Filesystem.File.GetCreationTimeUtc(notepadFile));
Assert.AreEqual(System.IO.File.GetLastAccessTime(notepadFile), Alphaleonis.Win32.Filesystem.File.GetLastAccessTime(notepadFile));
Assert.AreEqual(System.IO.File.GetLastAccessTimeUtc(notepadFile), Alphaleonis.Win32.Filesystem.File.GetLastAccessTimeUtc(notepadFile));
Assert.AreEqual(System.IO.File.GetLastWriteTime(notepadFile), Alphaleonis.Win32.Filesystem.File.GetLastWriteTime(notepadFile));
Assert.AreEqual(System.IO.File.GetLastWriteTimeUtc(notepadFile), Alphaleonis.Win32.Filesystem.File.GetLastWriteTimeUtc(notepadFile));
// We can not compare ChangeTime against .NET because it does not exist.
// Creating a file and renaming it triggers ChangeTime, so test for that.
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]\n", file.FullName);
var fileName = file.Name;
var changeTimeActual = Alphaleonis.Win32.Filesystem.File.GetChangeTime(file.FullName);
var changeTimeUtcActual = Alphaleonis.Win32.Filesystem.File.GetChangeTimeUtc(file.FullName);
// Sleep for three seconds.
var delay = 3;
file.MoveTo(file.FullName.Replace(fileName, fileName + "-Renamed"));
Thread.Sleep(delay * 1000);
file.MoveTo(file.FullName.Replace(fileName + "-Renamed", fileName));
var newChangeTime = changeTimeActual.AddSeconds(3);
Assert.AreEqual(changeTimeActual.AddSeconds(3), newChangeTime);
newChangeTime = changeTimeUtcActual.AddSeconds(3);
Assert.AreEqual(changeTimeUtcActual.AddSeconds(3), newChangeTime);
}
}
private void File_OpenRead_OpenReadTwiceShouldNotLock(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
using (Alphaleonis.Win32.Filesystem.File.OpenRead(file.FullName))
using (Alphaleonis.Win32.Filesystem.File.OpenRead(file.FullName)) {}
}
Console.WriteLine();
}
private void AlphaFS_Directory_CreateDirectory_FileExistsWithSameNameAsDirectory_ThrowsAlreadyExistsException(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
UnitTestAssert.ThrowsException <System.IO.IOException>(() => System.IO.Directory.CreateDirectory(file.FullName));
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.AlreadyExistsException>(() => Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(file.FullName));
}
Console.WriteLine();
}
private void AlphaFS_File_IsLocked(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
using (file.CreateText())
Assert.IsTrue(Alphaleonis.Win32.Filesystem.File.IsLocked(file.FullName), "The file is not locked, but is expected to.");
Assert.IsFalse(Alphaleonis.Win32.Filesystem.File.IsLocked(file.FullName), "The file is locked, but is expected not to.");
}
Console.WriteLine();
}
private void AlphaFS_File_GetSize(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
var fileLength = Alphaleonis.Win32.Filesystem.File.GetSize(file.FullName);
Console.WriteLine("\n\tFile sizes: [{0}] vs [{1}]", file.Length, fileLength);
Assert.AreEqual(file.Length, fileLength, "The file sizes do not match, but are expected to.");
}
Console.WriteLine();
}
private void AlphaFS_File_Delete_FileIsReadOnly_ThrowsFileReadOnlyException(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file);
System.IO.File.SetAttributes(file.FullName, System.IO.FileAttributes.ReadOnly);
UnitTestAssert.ThrowsException <UnauthorizedAccessException>(() => System.IO.File.Delete(file.FullName));
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.FileReadOnlyException>(() => Alphaleonis.Win32.Filesystem.File.Delete(file.FullName));
}
Console.WriteLine();
}
private void File_Move_ExistingFile(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var srcFile = tempRoot.CreateFile();
var dstFile = System.IO.Path.Combine(tempRoot.Directory.FullName, srcFile.Name + "-Moved.File");
var fileLength = srcFile.Length;
Console.WriteLine("Src File Path: [{0}] [{1}]", Alphaleonis.Utils.UnitSizeToText(srcFile.Length), srcFile.FullName);
Console.WriteLine("Dst File Path: [{0}]", dstFile);
var moveResult = Alphaleonis.Win32.Filesystem.File.Move(srcFile.FullName, dstFile, Alphaleonis.Win32.Filesystem.PathFormat.FullPath);
UnitTestConstants.Dump(moveResult);
// Test against moveResult results.
Assert.IsFalse(moveResult.IsCopy);
Assert.IsTrue(moveResult.IsMove);
Assert.IsFalse(moveResult.IsDirectory);
Assert.IsTrue(moveResult.IsFile);
Assert.AreEqual(fileLength, moveResult.TotalBytes);
Assert.AreEqual(1, moveResult.TotalFiles);
Assert.AreEqual(0, moveResult.TotalFolders);
Assert.IsFalse(System.IO.File.Exists(srcFile.FullName), "The file does exists, but is expected not to.");
Assert.IsTrue(System.IO.File.Exists(dstFile), "The file does not exists, but is expected to.");
var fileLen = new System.IO.FileInfo(dstFile).Length;
Assert.AreEqual(fileLength, fileLen, "The file copy is: {0} bytes, but is expected to be: {1} bytes.", fileLen, fileLength);
Assert.IsFalse(System.IO.File.Exists(srcFile.FullName), "The original file exists, but is expected not to.");
}
Console.WriteLine();
}
private void AlphaFS_File_GetFileIdInfo(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
var fid = Alphaleonis.Win32.Filesystem.File.GetFileIdInfo(file.FullName);
Console.WriteLine("\n\tToString(): {0}", fid);
Assert.IsNotNull(fid);
}
Console.WriteLine();
}
private void Directory_Delete_ThrowDirectoryNotFoundException_FileExistsWithSameNameAsDirectory(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
ExceptionAssert.IOException(() => System.IO.Directory.Delete(file.FullName));
// 2018-05-29 BUG: Throws wrong Exception.
ExceptionAssert.DirectoryNotFoundException(() => Alphaleonis.Win32.Filesystem.Directory.Delete(file.FullName));
}
Console.WriteLine();
}
private void AlphaFS_BackupFileStream_SegmentAlreadyUnlocked_ThrowsIOException(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
using (var bfs = new Alphaleonis.Win32.Filesystem.BackupFileStream(file.FullName, System.IO.FileMode.Open))
{
bfs.ReadStreamInfo();
UnitTestAssert.ThrowsException <System.IO.IOException>(() => bfs.Unlock(0, 10));
}
}
Console.WriteLine();
}
private void AlphaFS_BackupFileStream_InitializeInstance(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
using (var bfs = new Alphaleonis.Win32.Filesystem.BackupFileStream(file.FullName, System.IO.FileMode.Open))
{
UnitTestConstants.Dump(bfs.ReadStreamInfo());
UnitTestConstants.Dump(bfs);
}
}
Console.WriteLine();
}
private void AlphaFS_File_Move_DestinationFileAlreadyExists_ThrowsAlreadyExistsException(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var srcFile = tempRoot.CreateFile();
var dstFile = srcFile + "-Existing File";
Console.WriteLine("Src File Path: [{0}]", srcFile);
Console.WriteLine("Dst File Path: [{0}]", dstFile);
System.IO.File.Copy(srcFile.FullName, dstFile);
UnitTestAssert.ThrowsException <System.IO.IOException>(() => System.IO.File.Move(srcFile.FullName, dstFile));
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.AlreadyExistsException>(() => Alphaleonis.Win32.Filesystem.File.Move(srcFile.FullName, dstFile));
}
Console.WriteLine();
}
private void AlphaFS_File_Compress_And_Decompress(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
Alphaleonis.Win32.Filesystem.File.Compress(file.FullName);
FileAssert.IsCompressed(file.FullName);
Alphaleonis.Win32.Filesystem.File.Decompress(file.FullName);
FileAssert.IsNotCompressed(file.FullName);
}
Console.WriteLine();
}
private void File_GetAccessControl(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
var foundRules = false;
var sysIO = System.IO.File.GetAccessControl(file.FullName);
var sysIOaccessRules = sysIO.GetAccessRules(true, true, typeof(NTAccount));
var alphaFS = Alphaleonis.Win32.Filesystem.File.GetAccessControl(file.FullName);
var alphaFSaccessRules = alphaFS.GetAccessRules(true, true, typeof(NTAccount));
Console.WriteLine("\n\tSystem.IO rules found: [{0}]\n\tAlphaFS rules found : [{1}]", sysIOaccessRules.Count, alphaFSaccessRules.Count);
Assert.AreEqual(sysIOaccessRules.Count, alphaFSaccessRules.Count);
foreach (FileSystemAccessRule far in alphaFSaccessRules)
{
UnitTestConstants.Dump(far);
UnitTestConstants.TestAccessRules(sysIO, alphaFS);
foundRules = true;
}
Assert.IsTrue(foundRules);
}
}
public void AlphaFS_Path_GetFinalPathNameByHandle_ToGetFileStreamName_Success()
{
// Issue #438, filestream name.
// AlphaFS implementation of fileStream.Name returns = "[Unknown]"
// System.IO returns the full path.
using (var tempRoot = new TemporaryDirectory())
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]\n", file.FullName);
string sysIoStreamName;
using (var fs = file.Create())
sysIoStreamName = fs.Name;
using (var fs = Alphaleonis.Win32.Filesystem.File.Create(file.FullName))
{
var fileStreamName = Alphaleonis.Win32.Filesystem.Path.GetFinalPathNameByHandle(fs.SafeFileHandle);
fileStreamName = Alphaleonis.Win32.Filesystem.Path.GetRegularPath(fileStreamName);
Console.WriteLine("\tSystem.IO Filestream Name: " + sysIoStreamName);
Console.WriteLine("\tAlphaFS Filestream Name: " + fileStreamName);
Assert.AreEqual("[Unknown]", fs.Name);
Assert.AreEqual(sysIoStreamName, fileStreamName);
}
}
}
private void AlphaFS_File_GetProcessForFileLock(bool isNetwork)
{
var currentProcessId = System.Diagnostics.Process.GetCurrentProcess().Id;
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
using (file.CreateText())
{
var processes = Alphaleonis.Win32.Filesystem.File.GetProcessForFileLock(file.FullName);
var processesFound = processes.Count;
Console.WriteLine("\n\tProcesses found: [{0}]", processesFound);
Assert.AreEqual(1, processesFound);
foreach (var process in processes)
{
using (process)
{
UnitTestConstants.Dump(process, -26);
Assert.IsTrue(process.Id == currentProcessId, "File was locked by a process other than the current process.");
}
}
}
}
Console.WriteLine();
}
