private void DirectoryInfo_InitializeInstance_FolderNameGreaterThan255Characters_ThrowsPathTooLongException(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.Directory.FullName;
Console.WriteLine("Input Directory Path: [{0}]", folder);
// System.IO: 244, anything higher throws System.IO.PathTooLongException: The specified path, file name, or both are too long. The fully qualified file name must be less than 260 characters, and the directory name must be less than 248 characters.
// AlphaFS : 255, anything higher throws System.IO.PathTooLongException.
var subFolder = new string('b', 256);
var local = Alphaleonis.Win32.Filesystem.Path.Combine(folder, subFolder);
var unc = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(local);
Console.WriteLine("SubFolder length: {0}, total path length: {1}", subFolder.Length, isNetwork ? unc.Length : local.Length);
Console.WriteLine();
UnitTestAssert.ThrowsException <System.IO.PathTooLongException>(() => new System.IO.DirectoryInfo(isNetwork ? unc : local));
UnitTestAssert.ThrowsException <System.IO.PathTooLongException>(() => new Alphaleonis.Win32.Filesystem.DirectoryInfo(isNetwork ? unc : local));
}
Console.WriteLine();
}
private void File_Copy_DestinationFileIsReadOnly_ThrowsUnauthorizedAccessException(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var srcFile = tempRoot.CreateFile();
var dstFile = tempRoot.RandomTxtFileFullPath;
Console.WriteLine("Src File Path: [{0}]", srcFile.FullName);
Console.WriteLine("Dst File Path: [{0}]", dstFile);
System.IO.File.Copy(srcFile.FullName, dstFile);
System.IO.File.SetAttributes(dstFile, System.IO.FileAttributes.ReadOnly);
try
{
UnitTestAssert.ThrowsException <UnauthorizedAccessException>(() => System.IO.File.Copy(srcFile.FullName, dstFile, true));
UnitTestAssert.ThrowsException <UnauthorizedAccessException>(() => Alphaleonis.Win32.Filesystem.File.Copy(srcFile.FullName, dstFile, true));
}
finally
{
System.IO.File.SetAttributes(dstFile, System.IO.FileAttributes.Normal);
}
}
Console.WriteLine();
}
private void File_Move_NonExistingSourceDirectory_ThrowsDirectoryNotFoundException(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var srcFolder = UnitTestConstants.SysDrive + @"\NonExisting Source Folder\NonExisting Source File";
var dstFolder = UnitTestConstants.SysDrive + @"\NonExisting Destination Folder\NonExisting Destination File";
if (isNetwork)
{
srcFolder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(srcFolder);
dstFolder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(dstFolder);
}
Console.WriteLine("Src File Path: [{0}]", srcFolder);
Console.WriteLine("Dst File Path: [{0}]", dstFolder);
UnitTestAssert.ThrowsException <System.IO.FileNotFoundException>(() => System.IO.File.Move(srcFolder, dstFolder), srcFolder);
// 2018-05-29 BUG: Throws wrong Exception.
UnitTestAssert.ThrowsException <System.IO.DirectoryNotFoundException>(() => Alphaleonis.Win32.Filesystem.File.Move(srcFolder, dstFolder), srcFolder);
Console.WriteLine();
}
private void AlphaFS_BackupFileStream_FilePortionIsLocked_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))
try
{
bfs.ReadStreamInfo();
bfs.Lock(0, 10);
UnitTestAssert.ThrowsException <System.IO.IOException>(() => bfs.Lock(0, 10));
}
finally
{
bfs.Unlock(0, 10);
}
}
Console.WriteLine();
}
private void AlphaFS_Directory_Move_NonExistingSourceLogicalDrive_ThrowsDeviceNotReadyException(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var nonExistingDriveLetter = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter();
var srcFolder = nonExistingDriveLetter + @":\NonExisting Source Folder";
var dstFolder = UnitTestConstants.SysDrive + @"\NonExisting Destination Folder";
if (isNetwork)
{
srcFolder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(srcFolder);
dstFolder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(dstFolder);
}
Console.WriteLine("Src Directory Path: [{0}]", srcFolder);
Console.WriteLine("Dst Directory Path: [{0}]", dstFolder);
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.DeviceNotReadyException>(() => Alphaleonis.Win32.Filesystem.Directory.Move(srcFolder, dstFolder, Alphaleonis.Win32.Filesystem.MoveOptions.CopyAllowed));
Assert.IsFalse(System.IO.Directory.Exists(dstFolder), "The directory exists, but is expected not to.");
Console.WriteLine();
}
private void AlphaFS_File_Move_Overwrite_DestinationFileAlreadyExists(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var fileSource = tempRoot.CreateFile();
var fileCopy = tempRoot.CreateFile();
Console.WriteLine("Source File Path: [{0}]", fileSource.FullName);
UnitTestAssert.ThrowsException <System.IO.IOException>(() => System.IO.File.Move(fileSource.FullName, fileCopy.FullName));
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.AlreadyExistsException>(() => Alphaleonis.Win32.Filesystem.File.Move(fileSource.FullName, fileCopy.FullName));
Alphaleonis.Win32.Filesystem.File.Move(fileSource.FullName, fileCopy.FullName, Alphaleonis.Win32.Filesystem.MoveOptions.ReplaceExisting);
Assert.IsFalse(System.IO.File.Exists(fileSource.FullName), "The file does exists, but is expected not to.");
Assert.IsTrue(System.IO.File.Exists(fileCopy.FullName), "The file does not exists, but is expected to.");
}
Console.WriteLine();
}
private void AlphaFS_File_Move_NonExistingDestinationLogicalDrive_ThrowsDeviceNotReadyException(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var nonExistingDriveLetter = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter();
var srcFile = UnitTestConstants.SysDrive + @"\NonExisting Source File";
var dstFile = nonExistingDriveLetter + @":\NonExisting Destination File";
if (isNetwork)
{
srcFile = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(srcFile);
dstFile = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(dstFile);
}
Console.WriteLine("Src File Path: [{0}]", srcFile);
Console.WriteLine("Dst File Path: [{0}]", dstFile);
UnitTestAssert.ThrowsException <System.IO.FileNotFoundException>(() => System.IO.File.Move(srcFile, dstFile));
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.DeviceNotReadyException>(() => Alphaleonis.Win32.Filesystem.File.Move(srcFile, dstFile));
Assert.IsFalse(System.IO.Directory.Exists(dstFile), "The file exists, but is expected not to.");
Console.WriteLine();
}
private void Directory_Delete_DirectoryHasDenyPermission_ThrowsUnauthorizedAccessException(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(tempRoot.Directory.FullName, "Existing Source Folder"));
Console.WriteLine("Input Directory Path: [{0}]", folder);
// Set DENY permission for current user.
tempRoot.SetDirectoryDenyPermission(true, folder.FullName);
try
{
UnitTestAssert.ThrowsException <System.IO.IOException>(() => System.IO.Directory.Delete(folder.FullName));
// 2018-05-29 BUG: Throws wrong Exception.
UnitTestAssert.ThrowsException <UnauthorizedAccessException>(() => Alphaleonis.Win32.Filesystem.Directory.Delete(folder.FullName));
}
finally
{
// Remove DENY permission for current user.
tempRoot.SetDirectoryDenyPermission(false, folder.FullName);
}
}
Console.WriteLine();
}
private void AlphaFS_DirectoryInfo_MoveTo_DelayUntilReboot(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(tempRoot.RandomDirectoryFullPath);
var pendingEntry = folder.FullName;
Console.WriteLine("Src Directory Path: [{0}]", pendingEntry);
if (isNetwork)
{
// Trigger DelayUntilReboot.
UnitTestAssert.ThrowsException <ArgumentException>(() => folder.MoveTo(null, Alphaleonis.Win32.Filesystem.MoveOptions.DelayUntilReboot));
}
else
{
// Trigger DelayUntilReboot.
folder.MoveTo(null, Alphaleonis.Win32.Filesystem.MoveOptions.DelayUntilReboot);
UnitTestAssert.RegistryContainsPendingEntry(pendingEntry);
}
}
Console.WriteLine();
}
public void AlphaFS_Volume_DefineDosDevice_SymbolicLinkDriveMapping(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.CreateDirectory();
var drive = string.Format(CultureInfo.InvariantCulture, @"{0}:\", Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter(true));
Assert.IsFalse(System.IO.Directory.Exists(drive), "The drive exists, but it is expected not to.");
try
{
Alphaleonis.Win32.Filesystem.Volume.DefineDosDevice(drive, folder.FullName, Alphaleonis.Win32.Filesystem.DosDeviceAttributes.RawTargetPath);
// Remove Symbolic Link, no exact match: fail.
UnitTestAssert.ThrowsException <System.IO.FileNotFoundException>(() => Alphaleonis.Win32.Filesystem.Volume.DeleteDosDevice(drive, folder.FullName));
}
finally
{
// Remove Symbolic Link, exact match: success.
Alphaleonis.Win32.Filesystem.Volume.DeleteDosDevice(drive, folder.FullName, true);
Assert.IsFalse(System.IO.Directory.Exists(drive), "The drive exists, but it is expected not to.");
}
}
Console.WriteLine();
}
private void AlphaFS_File_Copy_Overwrite_DestinationFileAlreadyExists(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var srcFile = tempRoot.CreateFile();
var dstFile = tempRoot.CreateFile();
Console.WriteLine("Src File Path: [{0}]", srcFile.FullName);
Console.WriteLine("Dst File Path: [{0}]", dstFile.FullName);
UnitTestAssert.ThrowsException <System.IO.IOException>(() => System.IO.File.Copy(srcFile.FullName, dstFile.FullName));
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.AlreadyExistsException>(() => Alphaleonis.Win32.Filesystem.File.Copy(srcFile.FullName, dstFile.FullName));
Alphaleonis.Win32.Filesystem.File.Copy(srcFile.FullName, dstFile.FullName, true);
Assert.IsTrue(System.IO.File.Exists(srcFile.FullName), "The file does not exists, but is expected to.");
Assert.IsTrue(System.IO.File.Exists(dstFile.FullName), "The file does not exists, but is expected to.");
}
Console.WriteLine();
}
private void AlphaFS_Directory_CreateDirectory_NonExistingDriveLetter_ThrowsIOExceptionOrDeviceNotReadyException(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var folder = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter() + @":\NonExistingDriveLetter";
if (isNetwork)
{
folder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(folder);
}
Console.WriteLine("Input Directory Path: [{0}]", folder);
UnitTestAssert.ThrowsException <System.IO.IOException>(() => System.IO.Directory.CreateDirectory(folder));
// Local: IOException.
// UNC: IOException or DeviceNotReadyException.
// The latter occurs when a removable drive is already removed but there's still a cached reference.
var caught = UnitTestAssert.TestException <System.IO.IOException>(() => Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(folder));
if (!caught)
{
caught = UnitTestAssert.TestException <Alphaleonis.Win32.Filesystem.DeviceNotReadyException>(() => Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(folder));
}
Assert.IsTrue(caught);
Console.WriteLine();
}
private void AlphaFS_Directory_Delete_ThrowsDeviceNotReadyException_NonExistingLogicalDrive(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var nonExistingDriveLetter = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter();
var folder = nonExistingDriveLetter + @":\NonExisting Source Folder";
if (isNetwork)
{
folder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(folder);
}
Console.WriteLine("Input Directory Path: [{0}]", folder);
if (isNetwork)
{
UnitTestAssert.ThrowsException <System.IO.IOException>(() => System.IO.Directory.Delete(folder));
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.DeviceNotReadyException>(() => Alphaleonis.Win32.Filesystem.Directory.Delete(folder));
}
else
{
UnitTestAssert.ThrowsException <System.IO.DirectoryNotFoundException>(() => System.IO.Directory.Delete(folder));
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.DeviceNotReadyException>(() => Alphaleonis.Win32.Filesystem.Directory.Delete(folder));
}
Console.WriteLine();
}
public void Path_GetFullPath_InvalidLocalPath2_ThrowsArgumentException_Success()
{
UnitTestConstants.PrintUnitTestHeader(false);
UnitTestAssert.ThrowsException <ArgumentException>(() => System.IO.Path.GetFullPath(@"\\\\.txt"));
UnitTestAssert.ThrowsException <ArgumentException>(() => Alphaleonis.Win32.Filesystem.Path.GetFullPath(@"\\\\.txt"));
}
public void Path_GetFullPath_InvalidPath_ThrowsNotSupportedException_Success()
{
UnitTestConstants.PrintUnitTestHeader(false);
UnitTestAssert.ThrowsException <NotSupportedException>(() => System.IO.Path.GetFullPath(UnitTestConstants.SysDrive + @"\dev\test\aaa:aaa.txt"));
UnitTestAssert.ThrowsException <NotSupportedException>(() => Alphaleonis.Win32.Filesystem.Path.GetFullPath(UnitTestConstants.SysDrive + @"\dev\test\aaa:aaa.txt"));
}
public void Path_GetPathRoot_ThrowsArgumentExceptionEmptyString_Success()
{
UnitTestConstants.PrintUnitTestHeader(false);
UnitTestAssert.ThrowsException <ArgumentException>(() => System.IO.Path.GetPathRoot(string.Empty));
UnitTestAssert.ThrowsException <ArgumentException>(() => Alphaleonis.Win32.Filesystem.Path.GetPathRoot(string.Empty));
}
private void AlphaFS_Path_CheckSupportedPathFormat_PathStartsWithColon()
{
UnitTestConstants.PrintUnitTestHeader(false);
const string invalidPath = @":AAAAAAAAAA";
Console.WriteLine("Input Path: [{0}]", invalidPath);
UnitTestAssert.ThrowsException <ArgumentException>(() => Alphaleonis.Win32.Filesystem.Path.CheckSupportedPathFormat(invalidPath, true, true));
}
private void AlphaFS_DirectoryInfo_MoveTo_DelayUntilReboot(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(tempRoot.RandomDirectoryFullPath);
var pendingEntry = folder.FullName;
Console.WriteLine("Src Directory Path: [{0}]", pendingEntry);
if (isNetwork)
{
// Trigger DelayUntilReboot.
UnitTestAssert.ThrowsException <ArgumentException>(() => folder.MoveTo(null, Alphaleonis.Win32.Filesystem.MoveOptions.DelayUntilReboot));
}
else
{
// Trigger DelayUntilReboot.
folder.MoveTo(null, Alphaleonis.Win32.Filesystem.MoveOptions.DelayUntilReboot);
// Verify DelayUntilReboot in registry.
var pendingList = (string[])Registry.GetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager", "PendingFileRenameOperations", null);
Assert.IsNotNull(pendingList, "The PendingFileRenameOperations is null, but is not expected to.");
var found = false;
foreach (var line in pendingList)
{
found = !Alphaleonis.Utils.IsNullOrWhiteSpace(line) && line.Replace(pendingEntry, string.Empty).Equals(Alphaleonis.Win32.Filesystem.Path.NonInterpretedPathPrefix, StringComparison.Ordinal);
if (found)
{
Console.WriteLine("\n\tPending entry found in registry: [{0}]", line);
// TODO: Remove unit test entry from registry.
break;
}
}
Assert.IsTrue(found, "Registry does not contain pending entry, but is expected to.");
}
}
Console.WriteLine();
}
public void AlphaFS_Path_CheckSupportedPathFormat_PathContainsInvalidCharacters_ThrowsArgumentException_Local_Success()
{
using (var tempRoot = new TemporaryDirectory())
{
var folder = tempRoot.Directory.FullName + @"\ThisIs<My>File";
Console.WriteLine("Input Path: [{0}]", folder);
UnitTestAssert.ThrowsException <ArgumentException>(() => Alphaleonis.Win32.Filesystem.Path.CheckSupportedPathFormat(folder, true, true));
}
}
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 AlphaFS_Path_CheckSupportedPathFormat_PathContainsColon(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.Directory.FullName + @"\My:FilePath";
Console.WriteLine("Input Path: [{0}]", folder);
UnitTestAssert.ThrowsException <System.NotSupportedException>(() => Alphaleonis.Win32.Filesystem.Path.CheckSupportedPathFormat(folder, true, true));
}
Console.WriteLine();
}
private void AlphaFS_File_GetFileSystemEntryInfo_DirectoryExistsWithSameNameAsFile_ThrowsFileNotFoundException(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.CreateDirectoryRandomizedAttributes();
Console.WriteLine("Input Directory Path: [{0}]", folder.FullName);
UnitTestAssert.ThrowsException <System.IO.FileNotFoundException>(() => Alphaleonis.Win32.Filesystem.File.GetFileSystemEntryInfo(folder.FullName));
}
Console.WriteLine();
}
private void AlphaFS_Directory_Copy_Overwrite_DestinationFileAlreadyExists(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folderSrc = tempRoot.CreateTree();
var folderDst = tempRoot.RandomDirectoryFullPath;
Console.WriteLine("Src Directory Path: [{0}]", folderSrc.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", folderDst);
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst);
var dirEnumOptions = Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.FilesAndFolders | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive;
var props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(folderSrc.FullName, dirEnumOptions);
var sourceTotal = props["Total"];
var sourceTotalFiles = props["File"];
var sourceTotalSize = props["Size"];
Console.WriteLine("\n\tTotal size: [{0}] - Total Folders: [{1}] - Files: [{2}]", Alphaleonis.Utils.UnitSizeToText(sourceTotalSize), sourceTotal - sourceTotalFiles, sourceTotalFiles);
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.AlreadyExistsException>(() => Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst));
Assert.IsTrue(System.IO.Directory.Exists(folderDst), "The directory does not exist, but is expected to.");
// Overwrite using CopyOptions.None
var copyResult = Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst, Alphaleonis.Win32.Filesystem.CopyOptions.None);
props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(folderDst, dirEnumOptions);
Assert.AreEqual(sourceTotal, props["Total"], "The number of total file system objects does not match, but is expected to.");
Assert.AreEqual(sourceTotalFiles, props["File"], "The number of total files does not match, but is expected to.");
Assert.AreEqual(sourceTotalSize, props["Size"], "The total file size does not match, but is expected to.");
// Test against copyResult results.
Assert.IsNotNull(copyResult);
Assert.AreEqual(sourceTotal, copyResult.TotalFolders + copyResult.TotalFiles, "The number of total file system objects does not match, but is expected to.");
Assert.AreEqual(sourceTotalFiles, copyResult.TotalFiles, "The number of total files does not match, but is expected to.");
Assert.AreEqual(sourceTotalSize, copyResult.TotalBytes, "The total file size does not match, but is expected to.");
}
Console.WriteLine();
}
private void Directory_Delete_ThrowsDirectoryNotFoundException_NonExistingDirectory(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.RandomDirectoryFullPath;
Console.WriteLine("Input Directory Path: [{0}]", folder);
UnitTestAssert.ThrowsException <System.IO.DirectoryNotFoundException>(() => System.IO.Directory.Delete(folder));
UnitTestAssert.ThrowsException <System.IO.DirectoryNotFoundException>(() => Alphaleonis.Win32.Filesystem.Directory.Delete(folder));
}
Console.WriteLine();
}
private void File_Delete_PathIsADirectoryNotAFile_ThrowsUnauthorizedAccessException(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.CreateDirectory();
Console.WriteLine("Input Directory Path: [{0}]", folder.FullName);
UnitTestAssert.ThrowsException <UnauthorizedAccessException>(() => System.IO.File.Delete(folder.FullName));
UnitTestAssert.ThrowsException <UnauthorizedAccessException>(() => Alphaleonis.Win32.Filesystem.File.Delete(folder.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();
}
public void AlphaFS_Directory_CreateJunction_FromUncPath_ThrowsArgumentException_Netwerk_Success()
{
// Pass isNetwork to force Exception.
using (var tempRoot = new TemporaryDirectory(true))
{
var target = tempRoot.Directory.CreateSubdirectory("JunctionTarget");
var toDelete = tempRoot.Directory.CreateSubdirectory("ToDelete");
var junction = System.IO.Path.Combine(toDelete.FullName, "JunctionPoint");
UnitTestAssert.ThrowsException <ArgumentException>(() => Alphaleonis.Win32.Filesystem.Directory.CreateJunction(junction, target.FullName));
}
}
public void AlphaFS_Directory_CreateJunction_FileExistsWithSameNameAsDirectory_ThrowsIOException_Local_Success()
{
using (var tempRoot = new TemporaryDirectory())
{
var target = tempRoot.Directory.CreateSubdirectory("JunctionTarget");
var toDelete = tempRoot.Directory.CreateSubdirectory("ToDelete");
var junction = System.IO.Path.Combine(toDelete.FullName, "JunctionPoint");
// Create a file with the same name as the junction to trigger the IOException.
using (System.IO.File.CreateText(junction)) { }
UnitTestAssert.ThrowsException <System.IO.IOException>(() => Alphaleonis.Win32.Filesystem.Directory.CreateJunction(junction, target.FullName));
}
}
private void AlphaFS_Directory_Delete_ThrowsDirectoryReadOnlyException_DirectoryIsReadOnly(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(tempRoot.Directory.FullName, "Existing Source Folder"));
Console.WriteLine("Input Directory Path: [{0}]", folder);
System.IO.File.SetAttributes(folder.FullName, System.IO.FileAttributes.ReadOnly);
UnitTestAssert.ThrowsException <System.IO.IOException>(() => System.IO.Directory.Delete(folder.FullName));
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.DirectoryReadOnlyException>(() => Alphaleonis.Win32.Filesystem.Directory.Delete(folder.FullName));
}
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();
}
