private void Directory_Encrypt_And_Decrypt_Recursive(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folder = rootDir.RandomDirectoryFullPath;
Console.WriteLine("\nInput Directory Path: [{0}]\n", folder);
UnitTestConstants.CreateDirectoriesAndFiles(folder, 1, false, false, false);
// Encrypt.
Alphaleonis.Win32.Filesystem.Directory.Encrypt(folder, true);
// Verify that the entire folder is encrypted.
var cnt = 0;
foreach (var fsei in Alphaleonis.Win32.Filesystem.Directory.EnumerateFileSystemEntryInfos <Alphaleonis.Win32.Filesystem.FileSystemEntryInfo>(folder, Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive))
{
cnt++;
Assert.IsTrue((fsei.Attributes & System.IO.FileAttributes.Encrypted) != 0, "It is expected that the file system object is encrypted, but it is not.");
}
if (cnt == 0)
{
Assert.Inconclusive("Test encrypt: Nothing is enumerated, but it is expected.");
}
// Decrypt.
Alphaleonis.Win32.Filesystem.Directory.Decrypt(folder, true);
// Verify that the entire folder is decrypted.
cnt = 0;
foreach (var fsei in Alphaleonis.Win32.Filesystem.Directory.EnumerateFileSystemEntryInfos <Alphaleonis.Win32.Filesystem.FileSystemEntryInfo>(folder, Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive))
{
cnt++;
Assert.IsTrue((fsei.Attributes & System.IO.FileAttributes.Encrypted) == 0, "It is expected that the file system object is decrypted, but it is not.");
}
if (cnt == 0)
{
Assert.Inconclusive("Test decrypt: Nothing is enumerated, but it is expected.");
}
}
Console.WriteLine();
}
private void Directory_EnumerateFileSystemEntryInfos_FolderWithSpaceAsName(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folder = rootDir.Directory.FullName;
Console.WriteLine("\nInput Directory Path: [{0}]\n", folder);
var maxFolder = 10;
UnitTestConstants.CreateDirectoriesAndFiles(folder, maxFolder / 2, false, false, false);
for (var i = 0; i < maxFolder / 2; i++)
{
var spaceFolder = folder + @"\" + new string(' ', i + 1) + @"\" + "no_void";
Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(spaceFolder, Alphaleonis.Win32.Filesystem.PathFormat.LongFullPath);
}
var countNamedFolders = 0;
var countSpaceFolders = 0;
foreach (var fsei in Alphaleonis.Win32.Filesystem.Directory.EnumerateFileSystemEntryInfos <Alphaleonis.Win32.Filesystem.FileSystemInfo>(folder))
{
var path = fsei.FullName;
Console.WriteLine("\tDirectory: [{0}]", path);
if (char.IsWhiteSpace(path[path.Length - 1]))
{
countSpaceFolders++;
Assert.IsTrue(fsei.Exists);
}
else
{
countNamedFolders++;
}
}
Assert.AreEqual(maxFolder, countNamedFolders + countSpaceFolders);
}
Console.WriteLine();
}
private void Directory_CountFileSystemObjects_FoldersOnly_Recursive(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "Directory.CountFileSystemObjects"))
{
var folder = rootDir.RandomFileFullPath;
Console.WriteLine("\nInput Directory Path: [{0}]\n", folder);
const int expectedFso = 10;
const int expectedSubfolders = expectedFso * expectedFso + expectedFso;
UnitTestConstants.CreateDirectoriesAndFiles(folder, expectedFso, true);
var fsoCount = Alphaleonis.Win32.Filesystem.Directory.CountFileSystemObjects(folder, "*", Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Folders | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive);
Assert.AreEqual(expectedSubfolders, fsoCount, string.Format(CultureInfo.InvariantCulture, "The number of file system objects: {0} is not equal than expected: {1}", expectedSubfolders, fsoCount));
Console.WriteLine("\tTotal file system objects = [{0}]", fsoCount);
}
Console.WriteLine();
}
private void Directory_Copy_Overwrite_DestinationFileAlreadyExists(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "Directory.Copy"))
{
var folderSrc = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Source-") + System.IO.Path.GetRandomFileName());
var folderDst = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Destination-") + System.IO.Path.GetRandomFileName());
Console.WriteLine("\nSrc Directory Path: [{0}]", folderSrc.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", folderDst.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(folderSrc.FullName, new Random().Next(5, 15), true);
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("AlreadyExistsException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\n\tCaught Exception: [{0}] Message: [{1}]", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
// Overwrite using CopyOptions.None
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);
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName, Alphaleonis.Win32.Filesystem.CopyOptions.None);
props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(folderDst.FullName, dirEnumOptions);
Assert.AreEqual(sourceTotal, props["Total"], "The number of total file system objects do not match.");
Assert.AreEqual(sourceTotalFiles, props["File"], "The number of total files do not match.");
Assert.AreEqual(sourceTotalSize, props["Size"], "The total file size does not match.");
}
Console.WriteLine();
}
private void Directory_Copy_CatchAlreadyExistsException_DestinationFileAlreadyExists(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var gotException = false;
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var srcFolder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Existing Source Folder"));
var dstFolder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Existing Destination Folder"));
Console.WriteLine("Src Directory Path: [{0}]", srcFolder.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", dstFolder.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(srcFolder.FullName, 1, false, false, true);
// 1st Copy action.
Alphaleonis.Win32.Filesystem.Directory.Copy(srcFolder.FullName, dstFolder.FullName);
try
{
// 2nd Copy action.
Alphaleonis.Win32.Filesystem.Directory.Copy(srcFolder.FullName, dstFolder.FullName);
}
catch (Exception ex)
{
var exType = ex.GetType();
gotException = exType == typeof(Alphaleonis.Win32.Filesystem.AlreadyExistsException);
Console.WriteLine("\n\tCaught {0} Exception: [{1}] {2}", gotException ? "EXPECTED" : "UNEXPECTED", exType.Name, ex.Message);
}
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
Console.WriteLine();
}
private void Directory_DeleteEmptySubdirectories(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Source Folder"));
Console.WriteLine("\nInput Directory Path: [{0}]", folder.FullName);
const int maxDepth = 10;
const int totalDirectories = maxDepth * maxDepth + maxDepth; // maxDepth = 10: 110 directories and 110 files.
const int emptyDirectories = maxDepth * maxDepth / 2; // 50 empty directories.
const int remainingDirectories = totalDirectories - emptyDirectories; // 60 remaining directories.
var searchPattern = Alphaleonis.Win32.Filesystem.Path.WildcardStarMatchAll;
const Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions enumOptionsFolder = Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Folders | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.ContinueOnException;
const Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions enumOptionsFile = Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Files | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.ContinueOnException;
UnitTestConstants.CreateDirectoriesAndFiles(folder.FullName, maxDepth, false, false, true);
var dirs0 = Alphaleonis.Win32.Filesystem.Directory.CountFileSystemObjects(folder.FullName, searchPattern, enumOptionsFolder);
var files0 = Alphaleonis.Win32.Filesystem.Directory.CountFileSystemObjects(folder.FullName, searchPattern, enumOptionsFile);
Console.WriteLine("\n\tCounted Directories: [{0}] Empty Directories: [{1}]", dirs0, emptyDirectories);
Console.WriteLine("\tCounted Files : [{0}]", files0);
Alphaleonis.Win32.Filesystem.Directory.DeleteEmptySubdirectories(folder.FullName, true);
Assert.IsTrue(System.IO.Directory.Exists(folder.FullName), "The root directory does not exist, but is expected to.");
var dirs1 = Alphaleonis.Win32.Filesystem.Directory.CountFileSystemObjects(folder.FullName, searchPattern, enumOptionsFolder);
var files1 = Alphaleonis.Win32.Filesystem.Directory.CountFileSystemObjects(folder.FullName, searchPattern, enumOptionsFile);
Console.WriteLine("\n\tCounted Directories: [{0}]", dirs1);
Console.WriteLine("\tCounted Files : [{0}]", files1);
Assert.AreNotEqual(dirs0, dirs1, "The number of directories are equal, but are expected not to.");
Assert.AreEqual(remainingDirectories, dirs1, "The number of directories are not equal, but are expected to be.");
Assert.AreEqual(files0, files1, "The number of files are not equal, but are expected to be.");
Assert.AreEqual(totalDirectories, emptyDirectories + remainingDirectories, "The number of directories are not equal, but are expected to be.");
}
Console.WriteLine();
}
private void Directory_Move_Overwrite_DestinationDirectoryAlreadyExists(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folderSrc = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Existing Source Folder"));
var folderDst = new System.IO.DirectoryInfo(System.IO.Path.Combine(rootDir.Directory.FullName, "Destination Folder"));
Console.WriteLine("Src Directory Path: [{0}]", folderSrc.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", folderDst.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(folderSrc.FullName, 1, false, false, true);
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName);
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);
// Overwrite using MoveOptions.ReplaceExisting
Alphaleonis.Win32.Filesystem.Directory.Move(folderSrc.FullName, folderDst.FullName, Alphaleonis.Win32.Filesystem.MoveOptions.ReplaceExisting);
props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(folderDst.FullName, 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.");
}
Console.WriteLine();
}
private void Directory_Move_DifferentSourceAndDestination(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
using (var rootDir = new TemporaryDirectory(tempPath, "Directory.Move"))
{
var src = System.IO.Path.Combine(rootDir.Directory.FullName, "Source-") + System.IO.Path.GetRandomFileName();
var dst = System.IO.Path.Combine(rootDir.Directory.FullName, "Destination-") + System.IO.Path.GetRandomFileName();
if (isNetwork)
{
src = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(src);
}
else
{
dst = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(dst);
}
var folderSrc = System.IO.Directory.CreateDirectory(src);
var folderDst = new System.IO.DirectoryInfo(dst);
Console.WriteLine("\nSrc Directory Path: [{0}]", folderSrc.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", folderDst.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(folderSrc.FullName, new Random().Next(5, 15), true);
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);
Alphaleonis.Win32.Filesystem.Directory.Move(folderSrc.FullName, folderDst.FullName, Alphaleonis.Win32.Filesystem.MoveOptions.CopyAllowed);
props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(folderDst.FullName, dirEnumOptions);
Assert.AreEqual(sourceTotal, props["Total"], "The number of total file system objects do not match.");
Assert.AreEqual(sourceTotalFiles, props["File"], "The number of total files do not match.");
Assert.AreEqual(sourceTotalSize, props["Size"], "The total file size does not match.");
Assert.IsFalse(System.IO.Directory.Exists(folderSrc.FullName), "The original folder exists, but is expected not to.");
}
Console.WriteLine();
}
private void Directory_Move_CatchDirectoryNotFoundException_NonExistingDriveLetter(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "Directory.Move"))
{
var folderSrc = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter() + @":\NonExistingFolder";
if (isNetwork)
{
folderSrc = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(folderSrc);
}
Console.WriteLine("Dst Directory Path: [{0}]", folderSrc);
UnitTestConstants.CreateDirectoriesAndFiles(rootDir.Directory.FullName, new Random().Next(5, 15), true);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Move(rootDir.Directory.FullName, folderSrc, Alphaleonis.Win32.Filesystem.MoveOptions.CopyAllowed);
}
catch (Exception ex)
{
// Local: DirectoryNotFoundException.
// UNC: IOException.
var exName = ex.GetType().Name;
gotException = exName.Equals(isNetwork ? "IOException" : "DirectoryNotFoundException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\n\tCaught Exception: [{0}] Message: [{1}]", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
}
Console.WriteLine();
}
private void Directory_Copy_CatchAlreadyExistsException_DestinationFileAlreadyExists(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "Directory.Copy"))
{
var folderSrc = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Source-") + System.IO.Path.GetRandomFileName());
var folderDst = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Destination-") + System.IO.Path.GetRandomFileName());
Console.WriteLine("\nSrc Directory Path: [{0}]", folderSrc.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", folderDst.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(folderSrc.FullName, new Random().Next(5, 15), true);
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("AlreadyExistsException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\n\tCaught Exception: [{0}] Message: [{1}]", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
}
Console.WriteLine();
}
private void Directory_CountFileSystemObjects_FilesOnly_Recursive(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
const int expectedFso = 10;
long fsoCount;
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folder = rootDir.RandomDirectoryFullPath;
Console.WriteLine("Input Directory Path: [{0}]", folder);
UnitTestConstants.CreateDirectoriesAndFiles(folder, expectedFso, false, false, false);
fsoCount = Alphaleonis.Win32.Filesystem.Directory.CountFileSystemObjects(folder, "*", Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Files | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive);
Console.WriteLine("\tTotal file system objects = [{0}]", fsoCount);
}
Assert.AreEqual(expectedFso, fsoCount, string.Format(CultureInfo.InvariantCulture, "The number of file system objects are not equal, but are expected to."));
Console.WriteLine();
}
private void Directory_Move_ToDifferentVolume_EmulateUsingCopyDelete(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
using (var rootDir = new TemporaryDirectory(UnitTestConstants.TempFolder, MethodBase.GetCurrentMethod().Name))
{
var random = UnitTestConstants.GetRandomFileNameWithDiacriticCharacters();
var srcFolderName = System.IO.Path.Combine(rootDir.Directory.FullName, "Existing Source Folder.") + random;
var destFolderName = System.IO.Path.Combine(rootDir.Directory.FullName, "Destination Folder.") + random;
var folderSrc = isNetwork
? System.IO.Directory.CreateDirectory(Alphaleonis.Win32.Filesystem.Path.LocalToUnc(srcFolderName))
: System.IO.Directory.CreateDirectory(System.IO.Path.Combine(srcFolderName));
var folderDst = !isNetwork
? new System.IO.DirectoryInfo(Alphaleonis.Win32.Filesystem.Path.LocalToUnc(destFolderName))
: new System.IO.DirectoryInfo(destFolderName);
Console.WriteLine("\nSrc Directory Path: [{0}]", folderSrc.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", folderDst.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(folderSrc.FullName, new Random().Next(5, 15), false, false, true);
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);
var moveResult = Alphaleonis.Win32.Filesystem.Directory.Move(folderSrc.FullName, folderDst.FullName, Alphaleonis.Win32.Filesystem.MoveOptions.CopyAllowed);
UnitTestConstants.Dump(moveResult, -16);
props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(folderDst.FullName, dirEnumOptions);
Assert.AreEqual(sourceTotal, props["Total"], "The number of total file system objects do not match.");
Assert.AreEqual(sourceTotalFiles, props["File"], "The number of total files do not match.");
Assert.AreEqual(sourceTotalSize, props["Size"], "The total file size does not match.");
// Test against moveResult results.
var isMove = moveResult.IsMove;
Assert.AreEqual(sourceTotal, moveResult.TotalFolders + moveResult.TotalFiles, "The number of total file system objects do not match.");
Assert.AreEqual(sourceTotalFiles, moveResult.TotalFiles, "The number of total files do not match.");
Assert.AreEqual(sourceTotalSize, moveResult.TotalBytes, "The total file size does not match.");
Assert.IsFalse(isMove, "The action was expected to be a Copy, not a Move.");
Assert.IsTrue(moveResult.IsEmulatedMove, "The action was expected to be emulated (Copy + Delete).");
Assert.IsFalse(System.IO.Directory.Exists(folderSrc.FullName), "The original folder exists, but is expected not to.");
}
Console.WriteLine();
}
private void Directory_Copy_CatchUnauthorizedAccessException_UserExplicitDenyOnDestinationFolder(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var gotException = false;
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var srcFolder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Source Destination Folder"));
var dstFolder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Existing Destination Folder"));
Console.WriteLine("Src Directory Path: [{0}]", srcFolder.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", dstFolder.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(srcFolder.FullName, 1, false, false, true);
var user = (Environment.UserDomainName + @"\" + Environment.UserName).TrimStart('\\');
var rule = new System.Security.AccessControl.FileSystemAccessRule(user,
System.Security.AccessControl.FileSystemRights.FullControl,
System.Security.AccessControl.InheritanceFlags.ContainerInherit |
System.Security.AccessControl.InheritanceFlags.ObjectInherit,
System.Security.AccessControl.PropagationFlags.None,
System.Security.AccessControl.AccessControlType.Deny);
// Set DENY for current user.
var dirSecurity = dstFolder.GetAccessControl();
dirSecurity.AddAccessRule(rule);
dstFolder.SetAccessControl(dirSecurity);
try
{
Alphaleonis.Win32.Filesystem.Directory.Copy(srcFolder.FullName, dstFolder.FullName);
}
catch (Exception ex)
{
var exType = ex.GetType();
gotException = exType == typeof(UnauthorizedAccessException);
Console.WriteLine("\n\tCaught {0} Exception: [{1}] {2}", gotException ? "EXPECTED" : "UNEXPECTED", exType.Name, ex.Message);
}
finally
{
// Remove DENY for current user.
dirSecurity = dstFolder.GetAccessControl();
dirSecurity.RemoveAccessRule(rule);
dstFolder.SetAccessControl(dirSecurity);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
}
Console.WriteLine();
}
private void Directory_Copy(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folderSrc = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Source Folder"));
var folderDst = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Destination Folder"));
Console.WriteLine("Src Directory Path: [{0}]", folderSrc.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", folderDst.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(folderSrc.FullName, new Random().Next(5, 15), false, false, true);
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);
var copyResult = Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName, Alphaleonis.Win32.Filesystem.CopyOptions.FailIfExists);
UnitTestConstants.Dump(copyResult, -18);
props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(folderDst.FullName, dirEnumOptions);
Assert.AreEqual(sourceTotal, props["Total"], "The number of total file system objects do not match.");
Assert.AreEqual(sourceTotalFiles, props["File"], "The number of total files do not match.");
Assert.AreEqual(sourceTotalSize, props["Size"], "The total file size does not match.");
Assert.AreNotEqual(null, copyResult);
// Test against copyResult results.
Assert.AreEqual(sourceTotal, copyResult.TotalFolders + copyResult.TotalFiles, "The number of total file system objects do not match.");
Assert.AreEqual(sourceTotalFiles, copyResult.TotalFiles, "The number of total files do not match.");
Assert.AreEqual(sourceTotalSize, copyResult.TotalBytes, "The total file size does not match.");
Assert.IsTrue(copyResult.IsCopy);
Assert.IsFalse(copyResult.IsMove);
Assert.IsTrue(copyResult.IsDirectory);
Assert.IsFalse(copyResult.IsFile);
Assert.IsTrue(System.IO.Directory.Exists(folderSrc.FullName), "The original directory does not exist, but is expected to.");
}
Console.WriteLine();
}
private void Directory_Copy_Overwrite_DestinationFileAlreadyExists(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folderSrc = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Existing Source Folder"));
var folderDst = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Existing Destination Folder"));
Console.WriteLine("Src Directory Path: [{0}]", folderSrc.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", folderDst.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(folderSrc.FullName, 1, false, false, true);
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName);
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);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName);
}
catch (Exception ex)
{
var exType = ex.GetType();
gotException = exType == typeof(Alphaleonis.Win32.Filesystem.AlreadyExistsException);
//Console.WriteLine("\n\tCaught {0} Exception: [{1}] {2}", gotException ? "EXPECTED" : "UNEXPECTED", exType.Name, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
Assert.IsTrue(System.IO.Directory.Exists(folderDst.FullName), "The directory does not exist, but is expected to.");
// Overwrite using CopyOptions.None
var copyResult = Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc.FullName, folderDst.FullName, Alphaleonis.Win32.Filesystem.CopyOptions.None);
props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(folderDst.FullName, 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_Move_SameVolume(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var srcFolder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Existing Source Folder"));
var dstFolder = new System.IO.DirectoryInfo(System.IO.Path.Combine(rootDir.Directory.FullName, "Destination Folder"));
Console.WriteLine("Src Directory Path: [{0}]", srcFolder.FullName);
Console.WriteLine("Dst Directory Path: [{0}]", dstFolder.FullName);
UnitTestConstants.CreateDirectoriesAndFiles(srcFolder.FullName, new Random().Next(5, 15), false, false, true);
var dirEnumOptions = Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.FilesAndFolders | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive;
var props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(srcFolder.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);
var moveResult = Alphaleonis.Win32.Filesystem.Directory.Move(srcFolder.FullName, dstFolder.FullName, Alphaleonis.Win32.Filesystem.PathFormat.FullPath);
UnitTestConstants.Dump(moveResult, -16);
props = Alphaleonis.Win32.Filesystem.Directory.GetProperties(dstFolder.FullName, dirEnumOptions);
Assert.AreEqual(sourceTotal, props["Total"], "The number of total file system objects do not match.");
Assert.AreEqual(sourceTotalFiles, props["File"], "The number of total files do not match.");
Assert.AreEqual(sourceTotalSize, props["Size"], "The total file size does not match.");
// Test against moveResult results.
var isMove = moveResult.IsMove;
Assert.AreEqual(isMove ? 1 : sourceTotal, moveResult.TotalFolders + moveResult.TotalFiles, "The number of total file system objects do not match.");
Assert.AreEqual(isMove ? 0 : sourceTotalFiles, moveResult.TotalFiles, "The number of total files do not match.");
Assert.AreEqual(isMove ? 0 : sourceTotalSize, moveResult.TotalBytes, "The total file size does not match.");
Assert.IsTrue(isMove, "The action was expected to be a Move, not a Copy.");
Assert.IsFalse(moveResult.IsCopy);
Assert.IsTrue(moveResult.IsMove);
Assert.IsTrue(moveResult.IsDirectory);
Assert.IsFalse(moveResult.IsFile);
Assert.IsFalse(System.IO.Directory.Exists(srcFolder.FullName), "The original folder exists, but is expected not to.");
}
Console.WriteLine();
}
private void DirectoryInfo_MoveTo_DelayUntilReboot(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "DirectoryInfo.MoveTo_DelayUntilReboot"))
{
var folder = rootDir.Directory.FullName;
var folderSrc = Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(System.IO.Path.Combine(folder, "Source-" + System.IO.Path.GetRandomFileName()));
var pendingEntry = folderSrc.FullName;
Console.WriteLine("\nSrc Directory Path: [{0}]", pendingEntry);
UnitTestConstants.CreateDirectoriesAndFiles(pendingEntry, new Random().Next(5, 15), true);
// Trigger DelayUntilReboot.
folderSrc.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, which is not expected.");
var found = false;
foreach (var line in pendingList)
{
var entry = isNetwork ? pendingEntry.TrimStart('\\') : pendingEntry;
var prefix = @"\??\" + (isNetwork ? @"UNC\" : string.Empty);
found = !Alphaleonis.Utils.IsNullOrWhiteSpace(line) && line.Replace(entry, string.Empty).Equals(prefix, StringComparison.OrdinalIgnoreCase);
if (found)
{
Console.WriteLine("\n\tPending entry found in registry: [{0}]", line);
// TODO: Remove unit test entry from registry.
break;
}
}
Assert.IsTrue(found, "No pending entry found in registry, which is not expected.");
}
Console.WriteLine();
}
private void DumpGetSetAttributes(bool isLocal)
{
Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network);
var tmp = Path.Combine(Path.GetTempPath(), "File.SetAttributes()-" + Path.GetRandomFileName());
var tempPath = isLocal ? tmp : Path.LocalToUnc(tmp);
var sys32 = isLocal ? UnitTestConstants.SysRoot32 : Path.LocalToUnc(UnitTestConstants.SysRoot32);
Console.WriteLine("\nInput Path: [{0}]", sys32);
// Just enumerate and compare attributes in folder: C:\Windows\System32
foreach (var file in Directory.EnumerateFiles(sys32))
{
var actual = File.GetAttributes(file);
var expected = System.IO.File.GetAttributes(file);
Assert.AreEqual(expected, actual, "AlphaFS != System.IO");
}
Console.WriteLine("\nInput Path: [{0}]", tempPath);
// Create some folders and files.
UnitTestConstants.CreateDirectoriesAndFiles(tempPath, 10, true);
var apply = FileAttributes.Hidden | FileAttributes.Archive | FileAttributes.System | FileAttributes.ReadOnly;
Console.WriteLine("\nSetAttributes(): [{0}]", apply);
var allOk = true;
var cnt = 0;
UnitTestConstants.StopWatcher(true);
foreach (var file in Directory.EnumerateFiles(tempPath))
{
try
{
File.SetAttributes(file, apply);
var actual = File.GetAttributes(file);
var expected = System.IO.File.GetAttributes(file);
Console.WriteLine("\n\t#{0:000}\tFile : [{1}]\n\t\tAlphaFS : [{2}]\n\t\tSystem.IO: [{3}]", ++cnt, file, expected, actual);
if (cnt == 0)
{
Assert.Inconclusive("Nothing was enumerated, but it was expected.");
}
Assert.AreEqual(expected, actual, "AlphaFS != System.IO");
}
catch (Exception ex)
{
allOk = false;
Console.WriteLine("\n\tCaught (unexpected) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " "));
}
}
Console.WriteLine();
Console.WriteLine(UnitTestConstants.Reporter());
Assert.IsTrue(allOk);
apply = FileAttributes.Normal;
Console.WriteLine("\nSetAttributes(): [{0}]", apply);
allOk = true;
cnt = 0;
UnitTestConstants.StopWatcher(true);
foreach (var file in Directory.EnumerateFiles(tempPath))
{
try
{
File.SetAttributes(file, apply);
var actual = File.GetAttributes(file);
var expected = System.IO.File.GetAttributes(file);
Console.WriteLine("\n\t#{0:000}\tFile : [{1}]\n\t\tAlphaFS : [{2}]\n\t\tSystem.IO: [{3}]", ++cnt, file, expected, actual);
if (cnt == 0)
{
Assert.Inconclusive("Nothing was enumerated, but it was expected.");
}
Assert.AreEqual(expected, actual, "AlphaFS != System.IO");
}
catch (Exception ex)
{
allOk = false;
Console.WriteLine("\n\tCaught (unexpected) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " "));
}
}
Console.WriteLine();
Console.WriteLine(UnitTestConstants.Reporter());
Directory.Delete(tempPath, true);
Assert.IsFalse(Directory.Exists(tempPath), "Cleanup failed: Directory should have been removed.");
Assert.IsTrue(allOk);
Console.WriteLine();
}
private void DirectoryInfo_MoveTo_DelayUntilReboot(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folder = rootDir.Directory.FullName;
var folderSrc = Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(System.IO.Path.Combine(folder, "Source-" + UnitTestConstants.GetRandomFileNameWithDiacriticCharacters()));
var pendingEntry = folderSrc.FullName;
Console.WriteLine("Src Directory Path: [{0}]", pendingEntry);
UnitTestConstants.CreateDirectoriesAndFiles(pendingEntry, 1, false, false, true);
var gotException = false;
try
{
// Trigger DelayUntilReboot.
folderSrc.MoveTo(null, Alphaleonis.Win32.Filesystem.MoveOptions.DelayUntilReboot);
}
catch (Exception ex)
{
var exType = ex.GetType();
gotException = exType == typeof(ArgumentException);
Console.WriteLine("\n\tCaught {0} Exception: [{1}] {2}", gotException ? "EXPECTED" : "UNEXPECTED", exType.Name, ex.Message);
}
if (isNetwork)
{
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
}
else
{
// 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();
}
