private void File_Delete_CatchFileNotFoundException_NonExistingFile(bool isNetwork) { UnitTestConstants.PrintUnitTestHeader(isNetwork); var tempPath = System.IO.Path.GetTempPath() + "File.Delete-" + UnitTestConstants.GetRandomFileNameWithDiacriticCharacters(); if (isNetwork) { tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath); } Console.WriteLine("\nInput File Path: [{0}]", tempPath); var gotException = false; try { Alphaleonis.Win32.Filesystem.File.Delete(tempPath); } catch (Exception ex) { Assert.IsTrue(gotException, "An exception occurred, but is expected not to: " + ex.Message); } Console.WriteLine(); }
private void Directory_Delete_CatchDirectoryNotEmptyException_NonEmptyDirectory(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 folder = rootDir.RandomDirectoryFullPath; var file = System.IO.Path.Combine(folder, UnitTestConstants.GetRandomFileNameWithDiacriticCharacters()); Console.WriteLine("Input Directory Path: [{0}]", folder); Console.WriteLine("Input File Path : [{0}]", file); System.IO.Directory.CreateDirectory(folder); using (System.IO.File.Create(System.IO.Path.Combine(folder, file))) { } try { Alphaleonis.Win32.Filesystem.Directory.Delete(folder); } catch (Exception ex) { var exType = ex.GetType(); gotException = exType == typeof(Alphaleonis.Win32.Filesystem.DirectoryNotEmptyException); 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(); }
public void AlphaFS_Directory_CreateJunction_CatchArgumentException_MappedDrive_Netwerk_Success() { UnitTestConstants.PrintUnitTestHeader(false); var tempPath = System.IO.Path.GetTempPath(); using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name)) using (var connection = new Alphaleonis.Win32.Network.DriveConnection(Alphaleonis.Win32.Filesystem.Path.LocalToUnc(UnitTestConstants.TempFolder))) { var mappedPath = connection.LocalName + @"\" + UnitTestConstants.GetRandomFileNameWithDiacriticCharacters(); Console.WriteLine("\nUsing mapped drive: [{0}] to: [{1}]", connection.LocalName, connection.Share); var target = Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(mappedPath); var toDelete = rootDir.Directory.CreateSubdirectory("ToDelete"); var junction = System.IO.Path.Combine(toDelete.FullName, "JunctionPoint"); var gotException = false; try { Alphaleonis.Win32.Filesystem.Directory.CreateJunction(junction, target.FullName); } catch (Exception ex) { var exName = ex.GetType().Name; gotException = exName.Equals("ArgumentException", StringComparison.OrdinalIgnoreCase); Console.WriteLine("\n\tCaught {0} Exception: [{1}] {2}", gotException ? "EXPECTED" : "UNEXPECTED", exName, ex.Message); } Assert.IsTrue(gotException, "The exception is not caught, but is expected to."); target.Delete(); } }
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(); }
public TemporaryDirectory(string root, string prefix) { if (Utils.IsNullOrWhiteSpace(prefix)) { prefix = "AlphaFS"; } do { Directory = new System.IO.DirectoryInfo(System.IO.Path.Combine(root, prefix + "." + UnitTestConstants.GetRandomFileNameWithDiacriticCharacters().Substring(0, 6))); } while (Directory.Exists); Directory.Create(); }
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(); }
private void Directory_SetTimestampsXxx(bool isNetwork) { UnitTestConstants.PrintUnitTestHeader(isNetwork); var tempPath = System.IO.Path.GetTempPath(); if (isNetwork) { tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath); } var rnd = new Random(); using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name)) { var folder = rootDir.RandomDirectoryFullPath; var symlinkPath = System.IO.Path.Combine(rootDir.Directory.FullName, UnitTestConstants.GetRandomFileNameWithDiacriticCharacters()) + "-symlink"; Console.WriteLine("\nInput Directory Path: [{0}]", folder); System.IO.Directory.CreateDirectory(folder); Alphaleonis.Win32.Filesystem.Directory.CreateSymbolicLink(symlinkPath, folder); var creationTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59)); var lastAccessTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59)); var lastWriteTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59)); Alphaleonis.Win32.Filesystem.Directory.SetTimestamps(folder, creationTime, lastAccessTime, lastWriteTime); Assert.AreEqual(System.IO.Directory.GetCreationTime(folder), creationTime); Assert.AreEqual(System.IO.Directory.GetLastAccessTime(folder), lastAccessTime); Assert.AreEqual(System.IO.Directory.GetLastWriteTime(folder), lastWriteTime); // SymbolicLink Alphaleonis.Win32.Filesystem.Directory.SetTimestamps(symlinkPath, creationTime.AddDays(1), lastAccessTime.AddDays(1), lastWriteTime.AddDays(1), true, Alphaleonis.Win32.Filesystem.PathFormat.RelativePath); Assert.AreEqual(System.IO.Directory.GetCreationTime(symlinkPath), Alphaleonis.Win32.Filesystem.Directory.GetCreationTime(symlinkPath)); Assert.AreEqual(System.IO.Directory.GetLastAccessTime(symlinkPath), Alphaleonis.Win32.Filesystem.Directory.GetLastAccessTime(symlinkPath)); Assert.AreEqual(System.IO.Directory.GetLastWriteTime(symlinkPath), Alphaleonis.Win32.Filesystem.Directory.GetLastWriteTime(symlinkPath)); creationTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59)); lastAccessTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59)); lastWriteTime = new DateTime(rnd.Next(1971, 2071), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59)); Alphaleonis.Win32.Filesystem.Directory.SetTimestampsUtc(folder, creationTime, lastAccessTime, lastWriteTime); Assert.AreEqual(System.IO.Directory.GetCreationTimeUtc(folder), creationTime); Assert.AreEqual(System.IO.Directory.GetLastAccessTimeUtc(folder), lastAccessTime); Assert.AreEqual(System.IO.Directory.GetLastWriteTimeUtc(folder), lastWriteTime); // SymbolicLink Alphaleonis.Win32.Filesystem.Directory.SetTimestampsUtc(symlinkPath, creationTime.AddDays(1), lastAccessTime.AddDays(1), lastWriteTime.AddDays(1), true, Alphaleonis.Win32.Filesystem.PathFormat.RelativePath); Assert.AreEqual(System.IO.Directory.GetCreationTimeUtc(symlinkPath), Alphaleonis.Win32.Filesystem.File.GetCreationTimeUtc(symlinkPath)); Assert.AreEqual(System.IO.Directory.GetLastAccessTimeUtc(symlinkPath), Alphaleonis.Win32.Filesystem.File.GetLastAccessTimeUtc(symlinkPath)); Assert.AreEqual(System.IO.Directory.GetLastWriteTimeUtc(symlinkPath), Alphaleonis.Win32.Filesystem.File.GetLastWriteTimeUtc(symlinkPath)); } Console.WriteLine(); }
private void Directory_EnumerateAlternateDataStreams(bool isNetwork) { UnitTestConstants.PrintUnitTestHeader(isNetwork); var tempPath = Alphaleonis.Win32.Filesystem.Path.GetTempPath("Directory-EnumerateAlternateDataStreams-" + UnitTestConstants.GetRandomFileNameWithDiacriticCharacters()); if (isNetwork) { tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath); } const int defaultStreamsDirectory = 0; // The default number of data streams for a folder. Console.WriteLine("\nInput Directory Path: [{0}]", tempPath); Console.WriteLine("\nA directory is created and {0} streams are added.", UnitTestConstants.AllStreams.Count()); try { var di = new Alphaleonis.Win32.Filesystem.DirectoryInfo(tempPath); di.Create(); var currentNumberofStreams = di.EnumerateAlternateDataStreams().Count(); Assert.AreEqual(defaultStreamsDirectory, currentNumberofStreams, "Total amount of default streams do not match."); Assert.AreEqual(currentNumberofStreams, Alphaleonis.Win32.Filesystem.Directory.EnumerateAlternateDataStreams(tempPath).Count(), "Total amount of Directory.EnumerateAlternateDataStreams() streams do not match."); // Create alternate data streams. // Because of the colon, you must supply a full path and use PathFormat.FullPath or PathFormat.LongFullPath, // to prevent a: "NotSupportedException: path is in an invalid format." exception. Alphaleonis.Win32.Filesystem.File.WriteAllLines(tempPath + Alphaleonis.Win32.Filesystem.Path.StreamSeparator + UnitTestConstants.MyStream, UnitTestConstants.StreamArrayContent, Alphaleonis.Win32.Filesystem.PathFormat.FullPath); Alphaleonis.Win32.Filesystem.File.WriteAllText(tempPath + Alphaleonis.Win32.Filesystem.Path.StreamSeparator + UnitTestConstants.MyStream2, UnitTestConstants.StreamStringContent, Alphaleonis.Win32.Filesystem.PathFormat.FullPath); var newNumberofStreams = Alphaleonis.Win32.Filesystem.Directory.EnumerateAlternateDataStreams(tempPath).Count(); Console.WriteLine("\n\nCurrent stream Count(): [{0}]", newNumberofStreams); // Enumerate all streams from the folder. foreach (var stream in di.EnumerateAlternateDataStreams()) { Assert.IsTrue(UnitTestConstants.Dump(stream, -10)); } // Show the contents of our streams. Console.WriteLine(); foreach (var streamName in UnitTestConstants.AllStreams) { Console.WriteLine("\n\tStream name: [{0}]", streamName); // Because of the colon, you must supply a full path and use PathFormat.FullPath or PathFormat.LongFullPath, // to prevent a: "NotSupportedException: path is in an invalid format." exception. foreach (var line in Alphaleonis.Win32.Filesystem.File.ReadAllLines(tempPath + Alphaleonis.Win32.Filesystem.Path.StreamSeparator + streamName, Alphaleonis.Win32.Filesystem.PathFormat.FullPath)) { Console.WriteLine("\t\t{0}", line); } } } catch (Exception ex) { Console.WriteLine("\n\tCaught (UNEXPECTED) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); Assert.IsTrue(false); } finally { Alphaleonis.Win32.Filesystem.Directory.Delete(tempPath); Assert.IsFalse(Alphaleonis.Win32.Filesystem.Directory.Exists(tempPath), "Cleanup failed: Directory should have been removed."); } Console.WriteLine(); }
private void Directory_Exists_UseCases(bool isNetwork) { // Issue #288: Directory.Exists on root drive problem has come back with recent updates UnitTestConstants.PrintUnitTestHeader(isNetwork); Console.WriteLine(); var sysDrive = UnitTestConstants.SysDrive + @"\"; var tempPath = System.IO.Path.GetTempPath(); if (isNetwork) { sysDrive = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(sysDrive); tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath); } using (new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name)) { var randomName = UnitTestConstants.GetRandomFileNameWithDiacriticCharacters(); // C:\randomName var nonExistingFolder1 = UnitTestConstants.SysDrive + @"\" + randomName; // C:randomName var nonExistingFolder2 = UnitTestConstants.SysDrive + randomName; // C:\randomName-exists var existingFolder1 = nonExistingFolder1 + "-exists"; System.IO.Directory.CreateDirectory(existingFolder1); // C:randomName-exists var existingFolder2 = nonExistingFolder2 + "-exists"; System.IO.Directory.CreateDirectory(existingFolder1); if (isNetwork) { nonExistingFolder1 = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(nonExistingFolder1); nonExistingFolder2 = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(nonExistingFolder2); existingFolder1 = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(existingFolder1); existingFolder2 = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(existingFolder2); } // Some use cases. var paths = new Dictionary <string, List <bool> > { { nonExistingFolder1, new List <bool> { false, false } }, { nonExistingFolder2, new List <bool> { false, false } }, { nonExistingFolder1 + @"\", new List <bool> { false, false } }, { nonExistingFolder2 + @"\", new List <bool> { false, false } }, { existingFolder1, new List <bool> { true, true } }, { existingFolder2, new List <bool> { !isNetwork, !isNetwork } }, { existingFolder1 + @"\", new List <bool> { true, true } }, { existingFolder2 + @"\", new List <bool> { !isNetwork, !isNetwork } } }; try { System.IO.Directory.SetCurrentDirectory(sysDrive); Console.WriteLine("Current directory: " + System.IO.Directory.GetCurrentDirectory()); foreach (var path in paths) { var sysIOshouldBe = path.Value[0]; var alphaFSshouldBe = path.Value[1]; var inputPath = path.Key; var existSysIO = System.IO.Directory.Exists(inputPath); var existAlpha = Alphaleonis.Win32.Filesystem.Directory.Exists(inputPath); Console.WriteLine("\nSystem.IO (should be {0}):\t[{1}]\t\tdirectory= {2}", sysIOshouldBe.ToString().ToUpperInvariant(), existSysIO, inputPath); Console.WriteLine("AlphaFS (should be {0}):\t[{1}]\t\tdirectory= {2}", alphaFSshouldBe.ToString().ToUpperInvariant(), existAlpha, inputPath); Assert.AreEqual(sysIOshouldBe, existSysIO); Assert.AreEqual(alphaFSshouldBe, existAlpha); Assert.AreEqual(sysIOshouldBe, alphaFSshouldBe); } } finally { System.IO.Directory.Delete(existingFolder1); } } Console.WriteLine(); }
private void File_CreateHardlink_And_EnumerateHardlinks(bool isNetwork) { UnitTestConstants.PrintUnitTestHeader(isNetwork); var tempPath = System.IO.Path.GetTempPath(); using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name)) { var hardlinkFolder = System.IO.Path.Combine(rootDir.Directory.FullName, "Hardlinks"); System.IO.Directory.CreateDirectory(hardlinkFolder); var file = System.IO.Path.Combine(rootDir.Directory.FullName, "OriginalFile.txt"); Console.WriteLine("\nInput File Path: [{0}]\n", file); // Create original file with text content. System.IO.File.WriteAllText(file, UnitTestConstants.TextHelloWorld); // Create a random number of hardlinks to the original file. var numCreate = new Random().Next(1, 20); var hardlinks = new List <string>(); Console.WriteLine("Created {0} hardlinks:", numCreate + 1); for (var i = 0; i < numCreate; i++) { var newfile = System.IO.Path.Combine(hardlinkFolder, i + "-Hardlink-" + UnitTestConstants.GetRandomFileNameWithDiacriticCharacters() + ".txt"); Alphaleonis.Win32.Filesystem.File.CreateHardlink(newfile, file); hardlinks.Add(newfile); } var cnt = 0; foreach (var hardLink in Alphaleonis.Win32.Filesystem.File.EnumerateHardlinks(file)) { Console.WriteLine("\t\t#{0:000}\tHardlink: [{1}]", ++cnt, hardLink); } Assert.AreEqual(numCreate + 1, cnt); using (var stream = System.IO.File.OpenRead(file)) { UnitTestConstants.StopWatcher(true); var bhfi = Alphaleonis.Win32.Filesystem.File.GetFileInfoByHandle(stream.SafeFileHandle); Assert.AreEqual(numCreate + 1, bhfi.NumberOfLinks); Console.WriteLine("\n\n\tByHandleFileInfo for Input Path, see property: NumberOfLinks"); UnitTestConstants.Dump(bhfi, -18); } } Console.WriteLine(); }
private void Directory_GetFiles_WithSearchPattern(bool isLocal) { #region Setup UnitTestConstants.PrintUnitTestHeader(!isLocal); var tempPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "Directory.GetDirectories_With_SearchPattern()-" + UnitTestConstants.GetRandomFileNameWithDiacriticCharacters()); if (!isLocal) { tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath); } Console.WriteLine("\nInput Directory Path: [{0}]\n", tempPath); System.IO.Directory.CreateDirectory(tempPath); using (System.IO.File.Create(System.IO.Path.Combine(tempPath, "a.txt"))) { } using (System.IO.File.Create(System.IO.Path.Combine(tempPath, "aa.txt"))) { } using (System.IO.File.Create(System.IO.Path.Combine(tempPath, "aba.txt"))) { } using (System.IO.File.Create(System.IO.Path.Combine(tempPath, "foo.txt"))) { } using (System.IO.File.Create(System.IO.Path.Combine(tempPath, "footxt"))) { } #endregion // Setup try { var files = Alphaleonis.Win32.Filesystem.Directory.GetFiles(tempPath, "foo.txt"); Console.WriteLine("\tDirectory.GetFiles(tempPath, \"foo.txt\");"); Assert.IsTrue(files.Length == 1 && files.Contains(System.IO.Path.Combine(tempPath, "foo.txt"), StringComparer.InvariantCultureIgnoreCase)); Assert.IsFalse(files.Contains(System.IO.Path.Combine(tempPath, "fooatxt"), StringComparer.InvariantCultureIgnoreCase)); files = Alphaleonis.Win32.Filesystem.Directory.GetFiles(tempPath, "a?a.txt"); Console.WriteLine("\tDirectory.GetFiles(tempPath, \"a?a.txt\");"); Assert.IsTrue(files.Length == 1 && files.Contains(System.IO.Path.Combine(tempPath, "aba.txt"), StringComparer.InvariantCultureIgnoreCase), "? wildcard failed"); Assert.IsFalse(files.Contains(System.IO.Path.Combine(tempPath, "aa.txt"), StringComparer.InvariantCultureIgnoreCase), "? wildcard failed"); files = Alphaleonis.Win32.Filesystem.Directory.GetFiles(tempPath, "a*.*"); Console.WriteLine("\tDirectory.GetFiles(tempPath, \"a*.*\");"); Assert.IsTrue(files.Length == 3); Assert.IsTrue(files.Contains(System.IO.Path.Combine(tempPath, "a.txt"), StringComparer.InvariantCultureIgnoreCase), "* wildcard failed"); Assert.IsTrue(files.Contains(System.IO.Path.Combine(tempPath, "aa.txt"), StringComparer.InvariantCultureIgnoreCase), "* wildcard failed"); Assert.IsTrue(files.Contains(System.IO.Path.Combine(tempPath, "aba.txt"), StringComparer.InvariantCultureIgnoreCase), "* wildcard failed"); files = Alphaleonis.Win32.Filesystem.Directory.GetFiles(tempPath, "*.*"); Console.WriteLine("\tDirectory.GetFiles(tempPath, \"*.*\");"); var files2 = Alphaleonis.Win32.Filesystem.Directory.GetFiles(tempPath); Assert.IsTrue(files.Length == files2.Length, "*.* failed"); files = Alphaleonis.Win32.Filesystem.Directory.GetFiles(tempPath, "*.*.*"); Console.WriteLine("\tDirectory.GetFiles(tempPath, \"*.*.*\");"); Assert.IsTrue(files.Length == files2.Length, "*.* failed"); } finally { System.IO.Directory.Delete(tempPath, true); Assert.IsFalse(System.IO.Directory.Exists(tempPath), "Cleanup failed: Directory should have been removed."); Console.WriteLine(); } }
private void Directory_GetAccessControl(bool isNetwork) { UnitTestConstants.PrintUnitTestHeader(isNetwork); var tempPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "Directory.GetAccessControl()-" + UnitTestConstants.GetRandomFileNameWithDiacriticCharacters()); if (isNetwork) { tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath); } try { System.IO.Directory.CreateDirectory(tempPath); var foundRules = false; var sysIO = System.IO.File.GetAccessControl(tempPath); var sysIOaccessRules = sysIO.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount)); var alphaFS = System.IO.File.GetAccessControl(tempPath); var alphaFSaccessRules = alphaFS.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount)); Console.WriteLine("\nInput Directory Path: [{0}]", tempPath); Console.WriteLine("\n\tSystem.IO rules found: [{0}]\n\tAlphaFS rules found : [{1}]", sysIOaccessRules.Count, alphaFSaccessRules.Count); Assert.AreEqual(sysIOaccessRules.Count, alphaFSaccessRules.Count); foreach (var far in alphaFSaccessRules) { UnitTestConstants.Dump(far, -17); UnitTestConstants.TestAccessRules(sysIO, alphaFS); foundRules = true; } Assert.IsTrue(foundRules); } catch (Exception ex) { Console.WriteLine("\n\tCaught (UNEXPECTED) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); Assert.IsTrue(false); } finally { System.IO.Directory.Delete(tempPath, true); Assert.IsFalse(System.IO.Directory.Exists(tempPath), "Cleanup failed: Directory should have been removed."); } Console.WriteLine(); }