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