private void File_GetSize(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, "File-GetSize"))
{
var file = rootDir.RandomFileFullPath + ".txt";
Console.WriteLine("\nInput File Path: [{0}]]", file);
long streamLength;
var ten = UnitTestConstants.TenNumbers.Length;
using (var fs = System.IO.File.Create(file))
{
// According to NotePad++, creates a file type: "ANSI", which is reported as: "Unicode (UTF-8)".
fs.Write(UnitTestConstants.StringToByteArray(UnitTestConstants.TenNumbers), 0, ten);
streamLength = fs.Length;
}
var fileLength = Alphaleonis.Win32.Filesystem.File.GetSize(file);
Assert.IsTrue(fileLength == ten && fileLength == streamLength, "File should be [{0}] bytes in size.", ten);
}
Console.WriteLine();
}
private void AlphaFS_File_CreateSymbolicLink_And_GetLinkTargetInfo(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var fileLink = System.IO.Path.Combine(tempRoot.Directory.FullName, "FileLink-ToOriginalFile.txt");
var fileInfo = new System.IO.FileInfo(System.IO.Path.Combine(tempRoot.Directory.FullName, "OriginalFile.txt"));
using (fileInfo.CreateText()) {}
Console.WriteLine("Input File Path: [{0}]", fileInfo.FullName);
Console.WriteLine("Input File Link: [{0}]", fileLink);
Alphaleonis.Win32.Filesystem.File.CreateSymbolicLink(fileLink, fileInfo.FullName);
var lvi = Alphaleonis.Win32.Filesystem.File.GetLinkTargetInfo(fileLink);
UnitTestConstants.Dump(lvi);
Assert.IsTrue(lvi.PrintName.Equals(fileInfo.FullName, StringComparison.OrdinalIgnoreCase));
UnitTestConstants.Dump(new System.IO.FileInfo(fileLink));
var alphaFSFileInfo = new Alphaleonis.Win32.Filesystem.FileInfo(fileLink);
UnitTestConstants.Dump(alphaFSFileInfo.EntryInfo);
Assert.AreEqual(System.IO.File.Exists(alphaFSFileInfo.FullName), alphaFSFileInfo.Exists);
Assert.IsFalse(alphaFSFileInfo.EntryInfo.IsDirectory);
Assert.IsFalse(alphaFSFileInfo.EntryInfo.IsMountPoint);
Assert.IsTrue(alphaFSFileInfo.EntryInfo.IsReparsePoint);
Assert.IsTrue(alphaFSFileInfo.EntryInfo.IsSymbolicLink);
Assert.AreEqual(alphaFSFileInfo.EntryInfo.ReparsePointTag, Alphaleonis.Win32.Filesystem.ReparsePointTag.SymLink);
}
Console.WriteLine();
}
private void File_Copy_ExistingFile(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var fileSource = tempRoot.CreateFileRandomizedAttributes();
var fileCopy = tempRoot.RandomTxtFileFullPath;
Console.WriteLine("Src File Path: [{0}] [{1}]", Alphaleonis.Utils.UnitSizeToText(fileSource.Length), fileSource.FullName);
Console.WriteLine("Dst File Path: [{0}]", fileCopy);
Alphaleonis.Win32.Filesystem.File.Copy(fileSource.FullName, fileCopy);
Assert.IsTrue(System.IO.File.Exists(fileCopy), "The file does not exists, but is expected to.");
Assert.AreEqual(fileSource.Length, new System.IO.FileInfo(fileCopy).Length, "The file sizes do no match, but are expected to.");
Assert.IsTrue(System.IO.File.Exists(fileSource.FullName), "The original file does not exist, but is expected to.");
}
Console.WriteLine();
}
private void File_Replace_NoBackup(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var fileSrc = tempRoot.RandomTxtFileFullPath;
var fileDst = tempRoot.RandomTxtFileFullPath;
var fileBackup = tempRoot.RandomTxtFileFullPath + "-Backup.txt";
var text = System.IO.Path.GetRandomFileName();
Console.WriteLine("Src File Path: [{0}]", fileSrc);
Console.WriteLine("Dst File Path: [{0}]", fileDst);
Console.WriteLine("Backup File Path: [{0}]", fileBackup);
Console.WriteLine("Text : [{0}]", text);
using (var stream = System.IO.File.CreateText(fileSrc))
stream.Write(text);
using (var stream = System.IO.File.CreateText(fileDst))
stream.Write(text);
Alphaleonis.Win32.Filesystem.File.Replace(fileSrc, fileDst, null);
Assert.IsFalse(System.IO.File.Exists(fileSrc), "The file exists, but is expected not to.");
Assert.IsTrue(System.IO.File.Exists(fileDst), "The file does not exist, but is expected to.");
Assert.IsFalse(System.IO.File.Exists(fileBackup), "The file exists, but is expected not to.");
Assert.AreEqual(text, Alphaleonis.Win32.Filesystem.File.ReadAllText(fileDst), "The texts do not match, but are expected to.");
}
Console.WriteLine();
}
private void Directory_GetAccessControl(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.CreateDirectory();
Console.WriteLine("Input Directory Path: [{0}]", folder.FullName);
var foundRules = false;
var sysIO = System.IO.File.GetAccessControl(folder.FullName);
var sysIOaccessRules = sysIO.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
var alphaFS = System.IO.File.GetAccessControl(folder.FullName);
var alphaFSaccessRules = alphaFS.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
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);
}
Console.WriteLine();
}
private void Directory_Delete_CatchDirectoryNotFoundException_PathIsAFileNotADirectory(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.Delete"))
{
var file = rootDir.RandomFileFullPath + ".txt";
Console.WriteLine("\nInput File Path: [{0}]\n", file);
using (System.IO.File.Create(file)) { }
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Delete(file);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("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_CreateDirectory_CatchAlreadyExistsException_FileExistsWithSameNameAsDirectory(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 file = rootDir.RandomFileFullPath;
Console.WriteLine("\nInput File Path: [{0}]", file);
using (System.IO.File.Create(file)) { }
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(file);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("AlreadyExistsException", 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.");
}
Console.WriteLine();
}
private void AlphaFS_File_GetProcessForFileLock(bool isNetwork)
{
var currentProcessId = System.Diagnostics.Process.GetCurrentProcess().Id;
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]", file.FullName);
using (file.CreateText())
{
var processes = Alphaleonis.Win32.Filesystem.File.GetProcessForFileLock(file.FullName);
var processesFound = processes.Count;
Console.WriteLine("\n\tProcesses found: [{0}]", processesFound);
Assert.AreEqual(1, processesFound);
foreach (var process in processes)
{
using (process)
{
UnitTestConstants.Dump(process, -26);
Assert.IsTrue(process.Id == currentProcessId, "File was locked by a process other than the current process.");
}
}
}
}
Console.WriteLine();
}
public void AlphaFS_Path_GetMappedUncName()
{
using (var tempRoot = new TemporaryDirectory(true))
{
// Randomly test the share where the local folder possibly has the read-only and/or hidden attributes set.
var folder = tempRoot.CreateDirectoryRandomizedAttributes();
using (var connection = new Alphaleonis.Win32.Network.DriveConnection(folder.FullName))
{
var driveName = connection.LocalName;
Console.WriteLine("Mapped drive letter [{0}] to [{1}]", driveName, folder.FullName);
UnitTestConstants.Dump(connection, -9);
var connectionName = Alphaleonis.Win32.Filesystem.Path.GetMappedUncName(driveName);
Assert.AreEqual(folder.FullName, connectionName);
}
}
}
public void AlphaFS_Path_GetFinalPathNameByHandle_ToGetFileStreamName_Success()
{
// Issue #438, filestream name.
// AlphaFS implementation of fileStream.Name returns = "[Unknown]"
// System.IO returns the full path.
using (var tempRoot = new TemporaryDirectory())
{
var file = tempRoot.CreateFile();
Console.WriteLine("Input File Path: [{0}]\n", file.FullName);
string sysIoStreamName;
using (var fs = file.Create())
sysIoStreamName = fs.Name;
using (var fs = Alphaleonis.Win32.Filesystem.File.Create(file.FullName))
{
var fileStreamName = Alphaleonis.Win32.Filesystem.Path.GetFinalPathNameByHandle(fs.SafeFileHandle);
fileStreamName = Alphaleonis.Win32.Filesystem.Path.GetRegularPath(fileStreamName);
Console.WriteLine("\tSystem.IO Filestream Name: " + sysIoStreamName);
Console.WriteLine("\tAlphaFS Filestream Name: " + fileStreamName);
Assert.AreEqual("[Unknown]", fs.Name);
Assert.AreEqual(sysIoStreamName, fileStreamName);
}
}
}
private void File_CreateText(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, "File.CreateText"))
{
var file1 = rootDir.RandomFileFullPath + ".txt";
var file2 = rootDir.RandomFileFullPath + ".txt";
Console.WriteLine("\nInput File1 Path: [{0}]", file1);
Console.WriteLine("\nInput File2 Path: [{0}]", file2);
using (var stream = System.IO.File.CreateText(file1))
stream.Write(UnitTestConstants.TextHelloWorld);
using (var stream = Alphaleonis.Win32.Filesystem.File.CreateText(file2))
{
stream.Write(UnitTestConstants.TextHelloWorld);
Assert.AreEqual(stream.Encoding, Encoding.UTF8, "The text encoding is not equal, but is expected to.");
}
Assert.AreEqual(System.IO.File.ReadAllText(file1), System.IO.File.ReadAllText(file2), "The content of the two files is not equal, but is expected to.");
}
Console.WriteLine();
}
private void AlphaFS_Directory_DeleteEmptySubdirectories_DirectoryContainsAFile_DirectoryRemains(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(tempRoot.Directory.FullName, "Source Folder"));
Console.WriteLine("Input Directory Path: [{0}]", folder.FullName);
using (System.IO.File.Create(System.IO.Path.Combine(folder.FullName, "A File"))) { }
Alphaleonis.Win32.Filesystem.Directory.DeleteEmptySubdirectories(folder.FullName, true);
folder.Refresh();
var exists = folder.Exists;
Console.WriteLine("\n\tFolder exists: [{0}]", exists);
Assert.IsTrue(folder.Exists);
}
Console.WriteLine();
}
public void AlphaFS_Directory_CreateJunction_CatchDirectoryNotEmptyException_Local_Success()
{
UnitTestConstants.PrintUnitTestHeader(false);
var tempPath = System.IO.Path.GetTempPath();
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var target = rootDir.Directory.CreateSubdirectory("JunctionTarget");
var toDelete = rootDir.Directory.CreateSubdirectory("ToDelete");
var junction = System.IO.Path.Combine(toDelete.FullName, "JunctionPoint");
var dirInfo = new System.IO.DirectoryInfo(junction);
dirInfo.Create();
// Create an extra folder to trigger the DirectoryNotEmptyException.
dirInfo.CreateSubdirectory("Extra Folder");
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.CreateJunction(junction, target.FullName);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("DirectoryNotEmptyException", 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.");
}
}
private void File_Delete_CatchUnauthorizedAccessException_PathIsADirectoryNotAFile(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}]", folder);
System.IO.Directory.CreateDirectory(folder);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.File.Delete(folder);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("UnauthorizedAccessException", 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.");
}
Console.WriteLine();
}
private void Directory_Copy_CatchDirectoryNotFoundException_NonExistingDirectory(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.Path.Combine(rootDir.Directory.FullName, "Source-") + System.IO.Path.GetRandomFileName();
var folderDst = System.IO.Path.Combine(rootDir.Directory.FullName, "Destination-") + System.IO.Path.GetRandomFileName();
Console.WriteLine("\nSrc Directory Path: [{0}]", folderSrc);
Console.WriteLine("Dst Directory Path: [{0}]", folderDst);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Copy(folderSrc, folderDst);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("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_SetAccessControl(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, "File.SetAccessControl"))
{
var folder = rootDir.RandomFileFullPath;
Directory.CreateDirectory(folder);
var sysIO = System.IO.Directory.GetAccessControl(folder);
var sysIOaccessRules = sysIO.GetAccessRules(true, true, typeof(NTAccount));
var alphaFS = Directory.GetAccessControl(folder);
var alphaFSaccessRules = alphaFS.GetAccessRules(true, true, typeof(NTAccount));
Console.WriteLine("\nInput Directory Path: [{0}]", folder);
Console.WriteLine("\n\tSystem.IO rules found: [{0}]\n\tAlphaFS rules found : [{1}]", sysIOaccessRules.Count, alphaFSaccessRules.Count);
Assert.AreEqual(sysIOaccessRules.Count, alphaFSaccessRules.Count);
// Sanity check.
UnitTestConstants.TestAccessRules(sysIO, alphaFS);
// Remove inherited properties.
// Passing true for first parameter protects the new permission from inheritance,
// and second parameter removes the existing inherited permissions
Console.WriteLine("\n\tRemove inherited properties and persist it.");
alphaFS.SetAccessRuleProtection(true, false);
Directory.SetAccessControl(folder, alphaFS, AccessControlSections.Access);
// Re-read, using instance methods.
var sysIOdi = new System.IO.DirectoryInfo(folder);
var alphaFSdi = new DirectoryInfo(folder);
sysIO = sysIOdi.GetAccessControl(AccessControlSections.Access);
alphaFS = alphaFSdi.GetAccessControl(AccessControlSections.Access);
// Sanity check.
UnitTestConstants.TestAccessRules(sysIO, alphaFS);
// Restore inherited properties.
Console.WriteLine("\n\tRestore inherited properties and persist it.");
alphaFS.SetAccessRuleProtection(false, true);
Directory.SetAccessControl(folder, alphaFS, AccessControlSections.Access);
// Re-read.
sysIO = System.IO.Directory.GetAccessControl(folder, AccessControlSections.Access);
alphaFS = Directory.GetAccessControl(folder, AccessControlSections.Access);
// Sanity check.
UnitTestConstants.TestAccessRules(sysIO, alphaFS);
}
Console.WriteLine();
}
private void AlphaFS_Directory_Compress_And_Decompress(bool isNetwork, bool recursive)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.RandomDirectoryFullPath;
Console.WriteLine("Input Directory Path: [{0}]", folder);
var folderAaa = System.IO.Path.Combine(folder, "folder-aaa");
var folderBbb = System.IO.Path.Combine(folder, "folder-bbb");
var folderCcc = System.IO.Path.Combine(folderBbb, "folder-ccc");
System.IO.Directory.CreateDirectory(folderAaa);
System.IO.Directory.CreateDirectory(folderBbb);
System.IO.Directory.CreateDirectory(folderCcc);
var fileAaa = System.IO.Path.Combine(folderAaa, "file-aaa.txt");
var fileBbb = System.IO.Path.Combine(folderAaa, "file-bbb.txt");
var fileCcc = System.IO.Path.Combine(folder, "file-ccc.txt");
var fileDdd = System.IO.Path.Combine(folder, "file-ddd.txt");
using (System.IO.File.CreateText(fileAaa)) { }
using (System.IO.File.CreateText(fileBbb)) { }
using (System.IO.File.CreateText(fileCcc)) { }
using (System.IO.File.CreateText(fileDdd)) { }
Alphaleonis.Win32.Filesystem.Directory.Compress(folder, recursive ? Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive : Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.None);
DirectoryAssert.IsCompressed(folder);
DirectoryAssert.IsCompressed(folderAaa);
DirectoryAssert.IsCompressed(folderBbb);
FileAssert.IsCompressed(fileCcc);
FileAssert.IsCompressed(fileDdd);
if (recursive)
{
DirectoryAssert.IsCompressed(folderCcc);
FileAssert.IsCompressed(fileAaa);
FileAssert.IsCompressed(fileBbb);
}
else
{
DirectoryAssert.IsNotCompressed(folderCcc);
FileAssert.IsNotCompressed(fileAaa);
FileAssert.IsNotCompressed(fileBbb);
}
Alphaleonis.Win32.Filesystem.Directory.Decompress(folder, recursive ? Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive : Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.None);
if (recursive)
{
DirectoryAssert.IsNotCompressed(folderCcc);
FileAssert.IsNotCompressed(fileAaa);
FileAssert.IsNotCompressed(fileBbb);
}
else
{
DirectoryAssert.IsNotCompressed(folderCcc);
FileAssert.IsNotCompressed(fileAaa);
FileAssert.IsNotCompressed(fileBbb);
}
}
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 AlphaFS_Path_GetRelativePathResolveRelativePath(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var sysDrive = isNetwork ? Alphaleonis.Win32.Filesystem.Path.LocalToUnc(UnitTestConstants.SysDrive) : UnitTestConstants.SysDrive;
string[] relativePaths =
{
// fso = Folder or file.
@"a\b\c",
@"a\fso",
@"..\..\fso",
@"..\b\c",
@"a\b\c",
@"b\fso",
@"b\fso",
@"a\b\c",
@"a\b\c",
@"fso",
@"fso",
@"a\b\c",
@"\a\b\",
@"\",
@"..\..\",
@"a\b\",
sysDrive + @"\a",
sysDrive + @"\fso",
@"..\fso",
@"..\a",
sysDrive + @"\a",
sysDrive + @"\a\fso",
@"fso",
@"..\a",
sysDrive + @"\a",
sysDrive + @"\a\b\fso",
@"b\fso",
@"..\..\a",
sysDrive + @"\a",
sysDrive + @"\a\b\c\fso",
@"b\c\fso",
@"..\..\..\a",
sysDrive + @"\a",
sysDrive + @"\b\fso",
@"..\b\fso",
@"..\..\a",
sysDrive + @"\a",
sysDrive + @"\b\c\fso",
@"..\b\c\fso",
@"..\..\..\a",
sysDrive + @"\a\b",
sysDrive + @"\a\fso",
@"..\fso",
@"..\b",
sysDrive + @"\a\b",
sysDrive + @"\a",
@"..\a",
@"b",
sysDrive + @"\a\b",
sysDrive + @"\x\y\fso",
@"..\..\x\y\fso",
@"..\..\..\a\b",
sysDrive + @"\a\b\",
sysDrive + @"\",
@"..\..\",
@"a\b\",
sysDrive + @"\a\b\c",
sysDrive + @"\a\fso",
@"..\..\fso",
@"..\b\c",
sysDrive + @"\a\b\c",
sysDrive + @"\a\x\fso",
@"..\..\x\fso",
@"..\..\b\c",
sysDrive + @"\a\b\c",
sysDrive + @"\a\x\y\fso",
@"..\..\x\y\fso",
@"..\..\..\b\c",
sysDrive + @"\a\b\c",
sysDrive + @"\fso",
@"..\..\..\fso",
@"..\a\b\c",
tempRoot.Directory.FullName + @"\",
tempRoot.Directory.FullName + @"\",
string.Empty,
string.Empty,
tempRoot.Directory.FullName,
tempRoot.Directory.FullName,
tempRoot.Directory.Name,
tempRoot.Directory.Name
};
var totalPaths = relativePaths.Length;
for (var i = 0; i < totalPaths; i += 4)
{
var current = relativePaths[0 + i];
var selected = relativePaths[1 + i];
var shouldBeCurrent = relativePaths[2 + i];
var shouldBeSelected = relativePaths[3 + i];
var relative = Alphaleonis.Win32.Filesystem.Path.GetRelativePath(current, selected);
var absolute = Alphaleonis.Win32.Filesystem.Path.ResolveRelativePath(current, selected);
Console.WriteLine("\tCurrent : [{0}]", current);
Console.WriteLine("\tSelected: [{0}]", selected);
Console.WriteLine("\tRelative: [{0}]", relative);
var verify = System.IO.Path.IsPathRooted(current) && current[0] != Alphaleonis.Win32.Filesystem.Path.DirectorySeparatorChar;
if (verify)
{
Console.WriteLine("\tAbsolute: [{0}]", absolute);
Assert.AreEqual(selected, absolute, "The absolute paths do not match, but are expected to.");
}
Console.WriteLine();
Assert.AreEqual(shouldBeCurrent, relative, "The relative paths do not match, but are expected to.");
relative = Alphaleonis.Win32.Filesystem.Path.GetRelativePath(selected, current);
absolute = Alphaleonis.Win32.Filesystem.Path.ResolveRelativePath(selected, current);
Console.WriteLine("\t Current : [{0}]", selected);
Console.WriteLine("\t Selected: [{0}]", current);
Console.WriteLine("\t Relative: [{0}]", relative);
verify = System.IO.Path.IsPathRooted(selected) && selected[0] != Alphaleonis.Win32.Filesystem.Path.DirectorySeparatorChar;
if (verify)
{
Console.WriteLine("\t Absolute: [{0}]", absolute);
Assert.AreEqual(current, absolute, "The absolute paths do not match, but are expected to.");
}
Assert.AreEqual(shouldBeSelected, relative, "The relative paths do not match, but are expected to.");
Console.WriteLine();
}
}
}
private void AlphaFS_Directory_EnumerateAlternateDataStreams(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.RandomDirectoryFullPath;
Console.WriteLine("Input Directory Path: [{0}]", folder);
var myStream = "ӍƔŞtrëƛɱ-" + tempRoot.RandomString;
var myStream2 = "myStreamTWO-" + tempRoot.RandomString;
var allStreams = new[] { myStream, myStream2 };
var streamStringContent = "(1) Computer: [" + Environment.MachineName + "]" + "\tHello there, " + Environment.UserName;
Console.WriteLine("\nA directory is created and {0} streams are added.", allStreams.Length.ToString(CultureInfo.CurrentCulture));
var di = new Alphaleonis.Win32.Filesystem.DirectoryInfo(folder);
di.Create();
const int defaultStreamsDirectory = 0; // The default number of data streams for a folder.
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(folder).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.
var stream1Name = folder + Alphaleonis.Win32.Filesystem.Path.StreamSeparator + myStream;
var stream2Name = folder + Alphaleonis.Win32.Filesystem.Path.StreamSeparator + myStream2;
Alphaleonis.Win32.Filesystem.File.WriteAllLines(stream1Name, UnitTestConstants.StreamArrayContent, Alphaleonis.Win32.Filesystem.PathFormat.FullPath);
Alphaleonis.Win32.Filesystem.File.WriteAllText(stream2Name, streamStringContent, Alphaleonis.Win32.Filesystem.PathFormat.FullPath);
var newNumberofStreams = Alphaleonis.Win32.Filesystem.Directory.EnumerateAlternateDataStreams(folder).Count();
Console.WriteLine("\n\nNew 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 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(folder + Alphaleonis.Win32.Filesystem.Path.StreamSeparator + streamName, Alphaleonis.Win32.Filesystem.PathFormat.FullPath))
{
Console.WriteLine("\t\t{0}", line);
}
}
// Show DirectoryInfo instance data of the streams.
var dirInfo = new Alphaleonis.Win32.Filesystem.DirectoryInfo(stream1Name, Alphaleonis.Win32.Filesystem.PathFormat.LongFullPath);
Console.WriteLine();
UnitTestConstants.Dump(dirInfo, -17);
// Show FileInfo instance data of the streams.
var fileInfo1 = new Alphaleonis.Win32.Filesystem.FileInfo(stream1Name, Alphaleonis.Win32.Filesystem.PathFormat.LongFullPath);
var fileInfo2 = new Alphaleonis.Win32.Filesystem.FileInfo(stream2Name, Alphaleonis.Win32.Filesystem.PathFormat.LongFullPath);
Console.WriteLine();
UnitTestConstants.Dump(fileInfo1, -17);
UnitTestConstants.Dump(fileInfo2, -17);
Assert.AreEqual(myStream, fileInfo1.Name);
Assert.AreEqual(myStream2, fileInfo2.Name);
Assert.IsNull(fileInfo1.EntryInfo);
Assert.IsNull(fileInfo2.EntryInfo);
}
Console.WriteLine();
}
private void AlphaFS_EnumerateAlternateDataStreams(bool isNetwork)
{
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var file = tempRoot.RandomTxtFileFullPath;
Console.WriteLine("Input File Path: [{0}]", file);
var myStream = "ӍƔŞtrëƛɱ-" + tempRoot.RandomString;
var myStream2 = "myStreamTWO-" + tempRoot.RandomString;
var allStreams = new[] { myStream, myStream2 };
var streamStringContent = "(1) Computer: [" + Environment.MachineName + "]" + "\tHello there, " + Environment.UserName;
var tenNumbers = "0123456789";
Console.WriteLine("\nA file is created and {0} streams are added.", allStreams.Length.ToString(CultureInfo.CurrentCulture));
// Create file and add 10 characters to it, file is created in ANSI format.
System.IO.File.WriteAllText(file, tenNumbers);
var fi = new Alphaleonis.Win32.Filesystem.FileInfo(file);
const int defaultStreamsFile = 1; // The default number of data streams for a file.
var currentNumberofStreams = fi.EnumerateAlternateDataStreams().Count();
Assert.AreEqual(defaultStreamsFile, currentNumberofStreams, "Total amount of default streams do not match.");
Assert.AreEqual(currentNumberofStreams, Alphaleonis.Win32.Filesystem.File.EnumerateAlternateDataStreams(file).Count(), "Total amount of File.EnumerateAlternateDataStreams() streams do not match.");
var fileSize = Alphaleonis.Win32.Filesystem.File.GetSize(file);
Assert.AreEqual(tenNumbers.Length, fileSize);
// 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.
var stream1Name = file + Alphaleonis.Win32.Filesystem.Path.StreamSeparator + myStream;
var stream2Name = file + Alphaleonis.Win32.Filesystem.Path.StreamSeparator + myStream2;
Alphaleonis.Win32.Filesystem.File.WriteAllLines(stream1Name, UnitTestConstants.StreamArrayContent, Alphaleonis.Win32.Filesystem.PathFormat.FullPath);
Alphaleonis.Win32.Filesystem.File.WriteAllText(stream2Name, streamStringContent, Alphaleonis.Win32.Filesystem.PathFormat.FullPath);
var newNumberofStreams = Alphaleonis.Win32.Filesystem.File.EnumerateAlternateDataStreams(file).Count();
Console.WriteLine("\n\nNew stream count: [{0}]", newNumberofStreams);
// Enumerate all streams from the file.
foreach (var stream in fi.EnumerateAlternateDataStreams())
{
Assert.IsTrue(UnitTestConstants.Dump(stream, -10));
// The default stream, a file as we know it.
if (Alphaleonis.Utils.IsNullOrWhiteSpace(stream.StreamName))
{
Assert.AreEqual(fileSize, stream.Size);
}
}
// Show the contents of our streams.
Console.WriteLine();
foreach (var streamName in 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(file + Alphaleonis.Win32.Filesystem.Path.StreamSeparator + streamName, Alphaleonis.Win32.Filesystem.PathFormat.FullPath))
{
Console.WriteLine("\t\t{0}", line);
}
}
// Show FileInfo instance data of the streams.
var fileInfo1 = new Alphaleonis.Win32.Filesystem.FileInfo(stream1Name, Alphaleonis.Win32.Filesystem.PathFormat.LongFullPath);
var fileInfo2 = new Alphaleonis.Win32.Filesystem.FileInfo(stream2Name, Alphaleonis.Win32.Filesystem.PathFormat.LongFullPath);
Console.WriteLine();
UnitTestConstants.Dump(fileInfo1, -17);
UnitTestConstants.Dump(fileInfo2, -17);
Assert.AreEqual(myStream, fileInfo1.Name);
Assert.AreEqual(myStream2, fileInfo2.Name);
Assert.IsNull(fileInfo1.EntryInfo);
Assert.IsNull(fileInfo2.EntryInfo);
}
Console.WriteLine();
}
private void DirectoryInfo_Refresh(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.Refresh"))
{
var folder = rootDir.RandomFileFullPath;
var diSysIo = new System.IO.DirectoryInfo(folder + "-System.IO");
var diAlphaFS = new Alphaleonis.Win32.Filesystem.DirectoryInfo(folder + "-AlphaFS");
Console.WriteLine("\nSystem.IO Input Directory Path: [{0}]", diSysIo.FullName);
Console.WriteLine("AlphaFS Input Directory Path: [{0}]", diAlphaFS.FullName);
var existsSysIo = diSysIo.Exists;
var exists = diAlphaFS.Exists;
Assert.AreEqual(existsSysIo, exists);
Assert.IsFalse(exists, "The directory exists, but is expected not to.");
diSysIo.Create();
diAlphaFS.Create();
existsSysIo = diSysIo.Exists;
exists = diAlphaFS.Exists;
Assert.AreEqual(existsSysIo, exists);
Assert.IsFalse(exists, "The directory exists, but is expected not to.");
diSysIo.Refresh();
diAlphaFS.Refresh();
existsSysIo = diSysIo.Exists;
exists = diAlphaFS.Exists;
Assert.AreEqual(existsSysIo, exists);
Assert.IsTrue(exists, "The directory does not exists, but is expected to.");
diSysIo.Delete();
diAlphaFS.Delete();
existsSysIo = diSysIo.Exists;
exists = diAlphaFS.Exists;
Assert.AreEqual(existsSysIo, exists);
Assert.IsTrue(exists, "The directory does not exists, but is expected to.");
diSysIo.Refresh();
diAlphaFS.Refresh();
existsSysIo = diSysIo.Exists;
exists = diAlphaFS.Exists;
Assert.AreEqual(existsSysIo, exists);
Assert.IsFalse(exists, "The directory exists, but is expected not to.");
}
Console.WriteLine();
}
public void Directory_Move_FileToMappedDriveLetter_LocalAndNetwork_Success()
{
// Do not pass isNetwork, as to always use UnitTestConstants.TempPath
using (var tempRoot = new TemporaryDirectory())
{
const string srcFileName = "Src file.log";
const string dstFileName = "Dst file.log";
var srcFile = System.IO.Path.Combine(tempRoot.Directory.FullName, srcFileName);
var drive = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter() + @":\";
var share = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempRoot.Directory.Parent.FullName);
var dstFile = System.IO.Path.Combine(drive, dstFileName);
Alphaleonis.Win32.Network.Host.ConnectDrive(drive, share);
Console.WriteLine("Mapped drive [{0}] to [{1}]\n", drive, share);
System.IO.File.AppendAllText(srcFile, new string('*', new Random().Next(1, 1024)));
const Alphaleonis.Win32.Filesystem.MoveOptions options = Alphaleonis.Win32.Filesystem.MoveOptions.CopyAllowed | Alphaleonis.Win32.Filesystem.MoveOptions.WriteThrough | Alphaleonis.Win32.Filesystem.MoveOptions.ReplaceExisting;
Console.WriteLine("Src File Path: [{0}]", srcFile);
Console.WriteLine("Dst File Path: [{0}]", dstFile);
var cmr = Alphaleonis.Win32.Filesystem.Directory.Move(srcFile, dstFile, options);
UnitTestConstants.Dump(cmr);
Assert.IsFalse(System.IO.Directory.Exists(dstFile));
Assert.IsTrue(System.IO.File.Exists(dstFile));
Assert.AreEqual(new System.IO.FileInfo(srcFile).Length, new System.IO.FileInfo(dstFile).Length);
Assert.IsTrue(cmr.IsCopy);
Assert.IsTrue(cmr.IsEmulatedMove);
Assert.IsTrue(cmr.IsFile);
Assert.IsFalse(cmr.IsDirectory);
Assert.IsFalse(cmr.IsCanceled);
Assert.AreEqual(0, cmr.TotalFolders);
Assert.AreEqual(1, cmr.TotalFiles);
System.IO.File.Delete(dstFile);
Alphaleonis.Win32.Network.Host.DisconnectDrive(drive);
}
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();
}
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_Compress_Decompress(bool isNetwork, bool recursive)
{
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.Decompress"))
{
var rootFolder = rootDir.RandomFileFullPath + ".txt";
Console.WriteLine("\nInput Directory Path: [{0}]", rootFolder);
var folderAaa = System.IO.Path.Combine(rootFolder, "folder-aaa");
var folderBbb = System.IO.Path.Combine(rootFolder, "folder-bbb");
var folderCcc = System.IO.Path.Combine(folderBbb, "folder-ccc");
System.IO.Directory.CreateDirectory(folderAaa);
System.IO.Directory.CreateDirectory(folderBbb);
System.IO.Directory.CreateDirectory(folderCcc);
var fileAaa = System.IO.Path.Combine(folderAaa, "file-aaa.txt");
var fileBbb = System.IO.Path.Combine(folderAaa, "file-bbb.txt");
var fileCcc = System.IO.Path.Combine(rootFolder, "file-ccc.txt");
var fileDdd = System.IO.Path.Combine(rootFolder, "file-ddd.txt");
using (System.IO.File.CreateText(fileAaa)) { }
using (System.IO.File.CreateText(fileBbb)) { }
using (System.IO.File.CreateText(fileCcc)) { }
using (System.IO.File.CreateText(fileDdd)) { }
Alphaleonis.Win32.Filesystem.Directory.Compress(rootFolder, recursive ? Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive : Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.None);
DirectoryAssert.IsCompressed(rootFolder);
DirectoryAssert.IsCompressed(folderAaa);
DirectoryAssert.IsCompressed(folderBbb);
FileAssert.IsCompressed(fileCcc);
FileAssert.IsCompressed(fileDdd);
if (recursive)
{
DirectoryAssert.IsCompressed(folderCcc);
FileAssert.IsCompressed(fileAaa);
FileAssert.IsCompressed(fileBbb);
}
else
{
DirectoryAssert.IsNotCompressed(folderCcc);
FileAssert.IsNotCompressed(fileAaa);
FileAssert.IsNotCompressed(fileBbb);
}
Alphaleonis.Win32.Filesystem.Directory.Decompress(rootFolder, recursive ? Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive : Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.None);
if (recursive)
{
DirectoryAssert.IsNotCompressed(folderCcc);
FileAssert.IsNotCompressed(fileAaa);
FileAssert.IsNotCompressed(fileBbb);
}
else
{
DirectoryAssert.IsNotCompressed(folderCcc);
FileAssert.IsNotCompressed(fileAaa);
FileAssert.IsNotCompressed(fileBbb);
}
}
Console.WriteLine();
}
private void Directory_GetXxxTimeXxx(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 = isNetwork ? Alphaleonis.Win32.Filesystem.Path.LocalToUnc(UnitTestConstants.SysRoot32) : UnitTestConstants.SysRoot32;
Console.WriteLine("\nInput Directory Path: [{0}]", folder);
Assert.AreEqual(System.IO.Directory.GetCreationTime(folder), Alphaleonis.Win32.Filesystem.Directory.GetCreationTime(folder));
Assert.AreEqual(System.IO.Directory.GetCreationTimeUtc(folder), Alphaleonis.Win32.Filesystem.Directory.GetCreationTimeUtc(folder));
Assert.AreEqual(System.IO.Directory.GetLastAccessTime(folder), Alphaleonis.Win32.Filesystem.Directory.GetLastAccessTime(folder));
Assert.AreEqual(System.IO.Directory.GetLastAccessTimeUtc(folder), Alphaleonis.Win32.Filesystem.Directory.GetLastAccessTimeUtc(folder));
Assert.AreEqual(System.IO.Directory.GetLastWriteTime(folder), Alphaleonis.Win32.Filesystem.Directory.GetLastWriteTime(folder));
Assert.AreEqual(System.IO.Directory.GetLastWriteTimeUtc(folder), Alphaleonis.Win32.Filesystem.Directory.GetLastWriteTimeUtc(folder));
// We cannot compare ChangeTime against .NET because it does not exist.
// Creating a directory and renaming it triggers ChangeTime, so test for that.
folder = rootDir.RandomDirectoryFullPath;
if (isNetwork)
{
folder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(folder);
}
Console.WriteLine("Input Directory Path: [{0}]", folder);
var dirInfo = new System.IO.DirectoryInfo(folder);
dirInfo.Create();
var fileName = dirInfo.Name;
var changeTimeActual = Alphaleonis.Win32.Filesystem.Directory.GetChangeTime(folder);
var changeTimeUtcActual = Alphaleonis.Win32.Filesystem.Directory.GetChangeTimeUtc(folder);
// Sleep for three seconds.
var delay = 3;
dirInfo.MoveTo(dirInfo.FullName.Replace(fileName, fileName + "-Renamed"));
Thread.Sleep(delay * 1000);
dirInfo.MoveTo(dirInfo.FullName.Replace(fileName + "-Renamed", fileName));
var newChangeTime = changeTimeActual.AddSeconds(delay);
Assert.AreEqual(changeTimeActual.AddSeconds(delay), newChangeTime);
newChangeTime = changeTimeUtcActual.AddSeconds(delay);
Assert.AreEqual(changeTimeUtcActual.AddSeconds(delay), newChangeTime);
}
}
private void AlphaFS_File_Copy_3ExistingFiles_FromVolumeShadowCopy(bool isNetwork)
{
var testOk = false;
using (var tempRoot = new TemporaryDirectory(isNetwork))
{
var folder = tempRoot.CreateDirectoryRandomizedAttributes();
var dosDevices = Alphaleonis.Win32.Filesystem.Volume.QueryAllDosDevices().Where(device => device.StartsWith("HarddiskVolumeShadowCopy", StringComparison.OrdinalIgnoreCase)).ToArray();
foreach (var dosDevice in dosDevices)
{
if (testOk)
{
break;
}
var shadowSource = Alphaleonis.Win32.Filesystem.Path.GlobalRootDevicePrefix + dosDevice;
var sourceFolder = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
var drive = System.IO.Directory.GetDirectoryRoot(sourceFolder).TrimEnd('\\');
var globalRoot = sourceFolder.Replace(drive, shadowSource);
var dirInfo = new Alphaleonis.Win32.Filesystem.DirectoryInfo(globalRoot);
Console.WriteLine("Input GlobalRoot Path: [{0}]\n", dirInfo.FullName);
if (!dirInfo.Exists)
{
UnitTestAssert.InconclusiveBecauseFileNotFound("No volume shadow copy found.");
}
var enumOptions = Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.SkipReparsePoints;
var copyCount = 0;
foreach (var fileSource in dirInfo.EnumerateFiles(enumOptions))
{
if (copyCount == 3)
{
break;
}
var fileCopy = System.IO.Path.Combine(folder.FullName, System.IO.Path.GetFileName(fileSource.FullName));
Console.WriteLine("Copy file #{0}.", copyCount + 1);
var cmr = Alphaleonis.Win32.Filesystem.File.Copy(fileSource.FullName, fileCopy, Alphaleonis.Win32.Filesystem.CopyOptions.None);
UnitTestConstants.Dump(cmr);
Console.WriteLine();
Assert.AreEqual((int)Alphaleonis.Win32.Win32Errors.NO_ERROR, cmr.ErrorCode);
testOk = true;
copyCount++;
}
}
}
Console.WriteLine();
if (!testOk)
{
UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable();
}
}
private void BackupFileStream_InitializeInstance(bool isNetwork)
{
if (!System.IO.File.Exists(UnitTestConstants.NotepadExe))
{
Assert.Inconclusive("Test ignored because {0} was not found.", UnitTestConstants.NotepadExe);
}
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "BackupFileStream"))
{
var file = System.IO.Path.Combine(rootDir.Directory.FullName, System.IO.Path.GetFileName(UnitTestConstants.NotepadExe));
Console.WriteLine("\nInput File Path: [{0}]\n", file);
System.IO.File.Copy(UnitTestConstants.NotepadExe, file);
using (var bfs = new Alphaleonis.Win32.Filesystem.BackupFileStream(file, System.IO.FileMode.Open))
{
#region IOException
bfs.Lock(0, 10);
var gotException = false;
try
{
bfs.Lock(0, 10);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("IOException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\tCaught Exception (Expected): [{0}] Message: [{1}]", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
bfs.Unlock(0, 10);
#endregion // IOException
#region IOException #2
gotException = false;
try
{
bfs.Unlock(0, 10);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("IOException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\tCaught Exception (Expected): [{0}] Message: [{1}]", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
#endregion // IOException #2
UnitTestConstants.Dump(bfs.ReadStreamInfo(), -10);
Console.WriteLine();
UnitTestConstants.Dump(bfs, -14);
Console.WriteLine();
}
}
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();
}