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(); }