private void Directory_SetCurrentDirectory(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = Environment.SystemDirectory;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
Console.WriteLine("\tAlphaFS Set Current Directory Path: [{0}]\n", tempPath);
Alphaleonis.Win32.Filesystem.Directory.SetCurrentDirectory(tempPath, Alphaleonis.Win32.Filesystem.PathFormat.FullPath);
var sysIoCurrPath = System.IO.Directory.GetCurrentDirectory();
var alphaFSCurrPath = Alphaleonis.Win32.Filesystem.Directory.GetCurrentDirectory();
Console.WriteLine("\tSystem.IO Get Current Directory Path: [{0}]", sysIoCurrPath);
Console.WriteLine("\tAlphaFS Get Current Directory Path: [{0}]", alphaFSCurrPath);
Assert.AreEqual(sysIoCurrPath, alphaFSCurrPath, "The current directories do not match, but are expected to.");
Console.WriteLine();
}
public void AlphaFS_Volume_IsSameVolume()
{
UnitTestConstants.PrintUnitTestHeader(false);
Console.WriteLine();
var file1 = System.IO.Path.GetTempFileName();
var file2 = System.IO.Path.GetTempFileName();
var fileTmp = file2;
// Same C:
var isSame = Alphaleonis.Win32.Filesystem.Volume.IsSameVolume(file1, fileTmp);
Console.WriteLine("On same Volume (Should be True): [{0}]\n\tFile1: [{1}]\n\tFile2: [{2}]", isSame, file1, fileTmp);
Assert.IsTrue(isSame, "Should be the same volume.");
// Same C: -> C$
fileTmp = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(file2);
isSame = Alphaleonis.Win32.Filesystem.Volume.IsSameVolume(file1, fileTmp);
Console.WriteLine("\nOn same Volume (Should be True): [{0}]\n\tFile1: [{1}]\n\tFile2: [{2}]", isSame, file1, fileTmp);
Assert.IsTrue(isSame, "Should be the same volume.");
}
private void AlphaFS_Directory_Move_NonExistingDestinationLogicalDrive_ThrowsDeviceNotReadyException(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var nonExistingDriveLetter = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter();
var srcFolder = UnitTestConstants.SysDrive + @"\NonExisting Source Folder";
var dstFolder = nonExistingDriveLetter + @":\NonExisting Destination Folder";
if (isNetwork)
{
srcFolder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(srcFolder);
dstFolder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(dstFolder);
}
Console.WriteLine("Src Directory Path: [{0}]", srcFolder);
Console.WriteLine("Dst Directory Path: [{0}]", dstFolder);
UnitTestAssert.ThrowsException <Alphaleonis.Win32.Filesystem.DeviceNotReadyException>(() => Alphaleonis.Win32.Filesystem.Directory.Move(srcFolder, dstFolder, Alphaleonis.Win32.Filesystem.MoveOptions.CopyAllowed));
Assert.IsFalse(System.IO.Directory.Exists(dstFolder), "The directory exists, but is expected not to.");
Console.WriteLine();
}
private void Path_CheckSupportedPathFormat_CatchArgumentException_PathStartsWithColon()
{
UnitTestConstants.PrintUnitTestHeader(false);
Console.WriteLine();
var gotException = false;
const string invalidPath = @":AAAAAAAAAA";
Console.WriteLine("Invalid Path: [{0}]", invalidPath);
try
{
Alphaleonis.Win32.Filesystem.Path.CheckSupportedPathFormat(invalidPath, true, true);
}
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);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
Console.WriteLine();
}
private void VolumeInfo_InitializeInstance(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var cnt = 0;
foreach (var drive in Directory.GetLogicalDrives())
{
var tempPath = drive;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
try
{
var volInfo = Volume.GetVolumeInfo(tempPath);
Console.WriteLine("\n#{0:000}\tLogical Drive: [{1}]", ++cnt, tempPath);
UnitTestConstants.Dump(volInfo, -26);
}
catch (Exception ex)
{
Console.WriteLine("#{0:000}\tLogical Drive: [{1}]\n\tCaught: {2}: {3}", ++cnt, tempPath, ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " "));
}
Console.WriteLine();
}
if (cnt == 0)
{
Assert.Inconclusive("Nothing was enumerated, but it was expected.");
}
Console.WriteLine();
}
private void Directory_Delete_CatchArgumentException_PathContainsInvalidCharacters(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var folder = System.IO.Path.GetTempPath() + @"ThisIs<My>Folder";
Console.WriteLine("\nInput Directory Path: [{0}]\n", folder);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Delete(folder);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("ArgumentException", 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 Shell32_GetFileIcon(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var file = UnitTestConstants.NotepadExe;
if (isNetwork)
{
file = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(UnitTestConstants.NotepadExe);
}
Console.WriteLine("\nInput File Path: {0}", file);
var icon = IntPtr.Zero;
try
{
icon = Alphaleonis.Win32.Filesystem.Shell32.GetFileIcon(file, Alphaleonis.Win32.Filesystem.Shell32.FileAttributes.SmallIcon | Alphaleonis.Win32.Filesystem.Shell32.FileAttributes.AddOverlays);
Console.WriteLine("\n\tIcon Handle: [{0}]", icon);
Assert.AreNotEqual(icon, IntPtr.Zero, "The file does not contain an icon, but is expected to.");
}
finally
{
Alphaleonis.Win32.Filesystem.Shell32.DestroyIcon(icon);
}
Console.WriteLine();
}
private void EnumerateShares(string host)
{
UnitTestConstants.PrintUnitTestHeader(false);
Console.WriteLine("\nInput Host: [{0}]", host);
var cnt = 0;
foreach (var shareInfo in Alphaleonis.Win32.Network.Host.EnumerateShares(host, true))
{
//Console.WriteLine("\n\t#{0:000}\tShare: [{1}]", ++cnt, shareInfo);
if (UnitTestConstants.Dump(shareInfo, -18))
{
cnt++;
}
Console.WriteLine();
}
if (cnt == 0)
{
Assert.Inconclusive("Nothing is enumerated, but it is expected. Try another server name if applicable.");
}
Console.WriteLine();
}
private void Directory_GetFileSystemEntryInfo(bool isNetwork)
{
var path = UnitTestConstants.SysRoot;
if (!System.IO.Directory.Exists(path))
{
Assert.Inconclusive("Test ignored because {0} was not found.", path);
}
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = path;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
Console.WriteLine("\nInput Directory Path: [{0}]", tempPath);
var fsei = Alphaleonis.Win32.Filesystem.Directory.GetFileSystemEntryInfo(tempPath);
UnitTestConstants.Dump(fsei, -19);
Assert.IsTrue(fsei.GetType().IsEquivalentTo(typeof(Alphaleonis.Win32.Filesystem.FileSystemEntryInfo)));
Assert.IsTrue((fsei.Attributes & System.IO.FileAttributes.Directory) != 0, "The Directory attribute is not found, but is expected.");
Assert.AreEqual(tempPath, fsei.FullPath, "The paths are not equal, but are expected to be.");
Console.WriteLine();
}
private void AlphaFS_Volume_GetDriveFormat(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var logicalDriveCount = 0;
foreach (var driveInfo in System.IO.DriveInfo.GetDrives())
{
var driveName = isNetwork ? Alphaleonis.Win32.Filesystem.Path.LocalToUnc(driveInfo.Name) : driveInfo.Name;
Console.Write("#{0:000}\tInput Logical Drive Path: [{1}]", ++logicalDriveCount, driveName);
var driveFormat = Alphaleonis.Win32.Filesystem.Volume.GetDriveFormat(driveName);
Console.WriteLine("\t\tDrive Format: [{0}]", driveFormat);
// Some USB drives do not report drive format when path is UNC.
if (!Alphaleonis.Utils.IsNullOrWhiteSpace(driveFormat))
{
Assert.AreEqual(driveInfo.DriveFormat, driveFormat);
}
}
Assert.IsTrue(logicalDriveCount > 0, "No logical drives enumerated, but it is expected.");
Console.WriteLine();
}
public void AlphaFS_Host_EnumerateNetworks_Local_Success()
{
UnitTestConstants.PrintUnitTestHeader(false);
var networkCount = 0;
foreach (var networkInfo in Host.EnumerateNetworks().OrderBy(network => network.Name))
{
Console.WriteLine("#{0:000}\tNetwork: [{1}]", ++networkCount, networkInfo.Name);
UnitTestConstants.Dump(networkInfo, -21);
if (null != networkInfo.Connections)
{
foreach (var connectionInfo in networkInfo.Connections)
{
UnitTestConstants.Dump(connectionInfo.NetworkInterface, -20, true);
}
}
Console.WriteLine();
}
if (networkCount == 0)
{
UnitTestAssert.InconclusiveBecauseEnumerationIsEmpty();
}
}
private void File_Copy_WithProgress(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var tempPath = UnitTestConstants.TempFolder;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
// Min: 1 bytes, Max: 10485760 = 10 MB.
var fileLength = new Random().Next(1, 10485760);
var fileSource = UnitTestConstants.CreateFile(rootDir.Directory.FullName, fileLength);
var fileCopy = rootDir.RandomFileFullPath;
Console.WriteLine("Src File Path: [{0:N0} ({1}) [{2}]", fileLength, Alphaleonis.Utils.UnitSizeToText(fileLength), fileSource);
Console.WriteLine("Dst File Path: [{0}]", fileCopy);
Assert.IsTrue(System.IO.File.Exists(fileSource.FullName), "The file does not exists, but is expected to.");
// Allow copy to overwrite an existing file.
const Alphaleonis.Win32.Filesystem.CopyOptions copyOptions = Alphaleonis.Win32.Filesystem.CopyOptions.None;
// The copy progress handler.
var callback = new Alphaleonis.Win32.Filesystem.CopyMoveProgressRoutine(FileCopyProgressHandler);
Console.WriteLine();
// You can pass any piece of data to userProgressData. This data can be accessed from the callback method.
// Specify file length for assertion.
var userProgressData = fileLength;
var copyResult = Alphaleonis.Win32.Filesystem.File.Copy(fileSource.FullName, fileCopy, copyOptions, callback, userProgressData);
UnitTestConstants.Dump(copyResult, -18);
Assert.IsTrue(System.IO.File.Exists(fileCopy), "The file does not exists, but is expected to.");
var fileLen = new System.IO.FileInfo(fileCopy).Length;
Assert.AreEqual(fileLength, fileLen, "The file copy is: {0} bytes, but is expected to be: {1} bytes.", fileLen, fileLength);
Assert.IsTrue(System.IO.File.Exists(fileSource.FullName), "The original file does not exist, but is expected to.");
}
Console.WriteLine();
}
private void File_Compress_And_Decompress(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.Compress_Decompress"))
{
var file = rootDir.RandomFileFullPath + ".txt";
Console.WriteLine("\nInput File Path: [{0}]]", file);
using (System.IO.File.CreateText(file)) { }
Alphaleonis.Win32.Filesystem.File.Compress(file);
FileAssert.IsCompressed(file);
Alphaleonis.Win32.Filesystem.File.Decompress(file);
FileAssert.IsNotCompressed(file);
}
Console.WriteLine();
}
private void Shell32Info_InitializeInstance(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, "Shell32Info.Initialize_Instance"))
{
var file = rootDir.RandomFileFullPath + ".txt";
var shell32Info = new Alphaleonis.Win32.Filesystem.Shell32Info(file);
Assert.IsTrue(shell32Info != null);
UnitTestConstants.Dump(shell32Info, -15);
}
Console.WriteLine();
}
private void Directory_Delete_CatchDirectoryNotFoundException_NonExistingDirectory(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath() + "Directory.Delete-" + System.IO.Path.GetRandomFileName();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
Console.WriteLine("\nInput Directory Path: [{0}]\n", tempPath);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Delete(tempPath);
}
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 File_Delete_CatchFileNotFoundException_NonExistingFile(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath() + "File.Delete-" + System.IO.Path.GetRandomFileName();
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_CatchDirectoryNotFoundException_NonExistingDriveLetter(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var folder = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter() + @":\NonExistingDriveLetter";
if (isNetwork)
{
folder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(folder);
}
Console.WriteLine("\nInput Directory Path: [{0}]\n", folder);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Delete(folder);
}
catch (Exception ex)
{
// Local: DirectoryNotFoundException.
// UNC: IOException.
var exName = ex.GetType().Name;
gotException = exName.Equals(isNetwork ? "IOException" : "DirectoryNotFoundException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\n\tCaught Exception: [{0}] Message: [{1}]", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
Console.WriteLine();
}
private void File_Delete(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.Delete"))
{
var file = UnitTestConstants.CreateFile(rootDir.Directory.FullName);
Console.WriteLine("\nInput File Path: [{0}]", file);
Alphaleonis.Win32.Filesystem.File.Delete(file.FullName);
Assert.IsFalse(Alphaleonis.Win32.Filesystem.File.Exists(file.FullName), "The file exists, but is expected not to be.");
}
Console.WriteLine();
}
private void FileSystemEntryInfo_File_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 = UnitTestConstants.NotepadExe;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
Console.WriteLine("\nInput File Path: [{0}]", tempPath);
var fsei = Alphaleonis.Win32.Filesystem.File.GetFileSystemEntryInfo(tempPath);
UnitTestConstants.Dump(fsei, -17);
Assert.IsTrue(fsei.GetType().IsEquivalentTo(typeof(Alphaleonis.Win32.Filesystem.FileSystemEntryInfo)));
Assert.IsTrue(fsei.Attributes != System.IO.FileAttributes.Directory, "The directory attribute is found, but is not expected.");
Assert.AreEqual(tempPath, fsei.FullPath, "The paths are not equal, but are expected to be.");
Console.WriteLine();
}
private void Directory_Move_CatchArgumentException_PathStartsWithColon(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var folderSrc = @":AAAAAAAAAA";
Console.WriteLine("\nSrc Directory Path: [{0}]", folderSrc);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Move(folderSrc, string.Empty);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("ArgumentException", 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 AlphaFS_File_GetFileSystemEntryInfo(bool isNetwork)
{
var path = System.IO.Path.Combine(Environment.SystemDirectory, "notepad.exe");
if (!System.IO.File.Exists(path))
{
UnitTestAssert.InconclusiveBecauseFileNotFound(path);
}
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = path;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
Console.WriteLine("Input File Path: [{0}]", tempPath);
var fsei = Alphaleonis.Win32.Filesystem.File.GetFileSystemEntryInfo(tempPath);
UnitTestConstants.Dump(fsei, -19);
Assert.IsTrue(fsei.GetType().IsEquivalentTo(typeof(Alphaleonis.Win32.Filesystem.FileSystemEntryInfo)));
Assert.IsTrue(fsei.Attributes != System.IO.FileAttributes.Directory, "The directory attribute is found, but is not expected.");
Assert.AreEqual(tempPath, fsei.FullPath, "The paths are not equal, but are expected to be.");
Console.WriteLine();
}
private void Directory_Move_Rename(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, "Directory.Move (Rename)"))
{
var folderSrc = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Source-") + System.IO.Path.GetRandomFileName());
var folderDst = new System.IO.DirectoryInfo(System.IO.Path.Combine(rootDir.Directory.FullName, "Destination-") + System.IO.Path.GetRandomFileName());
Console.WriteLine("\nInput Directory Path: [{0}]", folderSrc.FullName);
Console.WriteLine("\nRename folder: [{0}] to: [{1}]", folderSrc.Name, folderDst.Name);
Assert.IsTrue(folderSrc.Exists, "The source folder does not exist which was not expected.");
Assert.IsFalse(folderDst.Exists, "The destination folder exists which was not expected.");
Alphaleonis.Win32.Filesystem.Directory.Move(folderSrc.FullName, folderDst.FullName);
folderSrc.Refresh();
folderDst.Refresh();
Assert.IsFalse(folderSrc.Exists, "The source folder exists which was not expected.");
Assert.IsTrue(folderDst.Exists, "The destination folder does not exists which was not expected.");
}
Console.WriteLine();
}
private void AlphaFS_Directory_EnumerateFileSystemEntryInfos_TypeFileSystemEntryInfo(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = Environment.SystemDirectory;
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
Console.WriteLine("Input Directory Path: [{0}]\n", tempPath);
var count = 0;
foreach (var fsei in Alphaleonis.Win32.Filesystem.Directory.EnumerateFileSystemEntryInfos <Alphaleonis.Win32.Filesystem.FileSystemEntryInfo>(tempPath))
{
Assert.IsTrue(fsei.GetType().IsEquivalentTo(typeof(Alphaleonis.Win32.Filesystem.FileSystemEntryInfo)));
count++;
}
Assert.IsTrue(count > 0, "Nothing is enumerated, but it is expected.");
}
public void AlphaFS_Host_EnumerateShares_Local_Success()
{
UnitTestConstants.PrintUnitTestHeader(false);
var host = Environment.MachineName;
Console.WriteLine("Input Host: [{0}]", host);
var count = 0;
foreach (var shareInfo in Alphaleonis.Win32.Network.Host.EnumerateShares(host, true))
{
UnitTestConstants.Dump(shareInfo);
Assert.IsNotNull(shareInfo);
count++;
Console.WriteLine();
}
if (count == 0)
{
UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable();
}
}
private void EnumerateOpenConnections(string host, string share)
{
//UnitTestAssert.IsElevatedProcess(); // In User mode nothing is enumerated.
UnitTestConstants.PrintUnitTestHeader(false);
Console.WriteLine("Connected to Share: [{0}\\{1}]", host, share);
var count = 0;
foreach (var openConnectionInfo in Alphaleonis.Win32.Network.Host.EnumerateOpenConnections(host, share, true))
{
UnitTestConstants.Dump(openConnectionInfo);
Assert.IsNotNull(openConnectionInfo);
count++;
Console.WriteLine();
}
if (count == 0)
{
UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable();
}
}
private void Directory_IsEmpty_ContainsAFile_IsFalse(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folder = System.IO.Directory.CreateDirectory(System.IO.Path.Combine(rootDir.Directory.FullName, "Empty Folder"));
Console.WriteLine("\nInput Directory Path: [{0}]", folder.FullName);
// Create file and test again.
var file = System.IO.Path.Combine(folder.FullName, "a_file.txt");
using (System.IO.File.Create(file))
Console.WriteLine("\n\tCreated File: [{0}]", file);
Assert.IsFalse(Alphaleonis.Win32.Filesystem.Directory.IsEmpty(folder.FullName), "It is expected that the folder is not empty.");
}
Console.WriteLine();
}
private void AlphaFS_Directory_CreateDirectory_NonExistingDriveLetter_ThrowsIOExceptionOrDeviceNotReadyException(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var folder = Alphaleonis.Win32.Filesystem.DriveInfo.GetFreeDriveLetter() + @":\NonExistingDriveLetter";
if (isNetwork)
{
folder = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(folder);
}
Console.WriteLine("Input Directory Path: [{0}]", folder);
UnitTestAssert.ThrowsException <System.IO.IOException>(() => System.IO.Directory.CreateDirectory(folder));
// Local: IOException.
// UNC: IOException or DeviceNotReadyException.
// The latter occurs when a removable drive is already removed but there's still a cached reference.
var caught = UnitTestAssert.TestException <System.IO.IOException>(() => Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(folder));
if (!caught)
{
caught = UnitTestAssert.TestException <Alphaleonis.Win32.Filesystem.DeviceNotReadyException>(() => Alphaleonis.Win32.Filesystem.Directory.CreateDirectory(folder));
}
Assert.IsTrue(caught);
Console.WriteLine();
}
private void Directory_Delete_CatchNotSupportedException_PathContainsColon(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var colonText = @"\My:FolderPath";
var folder = (isNetwork ? Alphaleonis.Win32.Filesystem.Path.LocalToUnc(UnitTestConstants.LocalHostShare) : UnitTestConstants.SysDrive + @"\dev\test") + colonText;
Console.WriteLine("\nInput Directory Path: [{0}]\n", folder);
var gotException = false;
try
{
Alphaleonis.Win32.Filesystem.Directory.Delete(folder);
}
catch (Exception ex)
{
var exName = ex.GetType().Name;
gotException = exName.Equals("NotSupportedException", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("\n\tCaught Exception: [{0}] Message: [{1}]", exName, ex.Message);
}
Assert.IsTrue(gotException, "The exception is not caught, but is expected to.");
Console.WriteLine();
}
private void Directory_CountFileSystemObjects_FoldersAndFiles_Recursive(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
var tempPath = System.IO.Path.GetTempPath();
if (isNetwork)
{
tempPath = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(tempPath);
}
using (var rootDir = new TemporaryDirectory(tempPath, MethodBase.GetCurrentMethod().Name))
{
var folder = rootDir.RandomDirectoryFullPath;
Console.WriteLine("\nInput Directory Path: [{0}]\n", folder);
const int expectedFso = 200;
UnitTestConstants.CreateDirectoriesAndFiles(folder, 100, false, false, false);
var fsoCount = Alphaleonis.Win32.Filesystem.Directory.CountFileSystemObjects(folder, "*", Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.FilesAndFolders | Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive);
Console.WriteLine("\tTotal file system objects = [{0}]", fsoCount);
Assert.AreEqual(expectedFso, fsoCount, string.Format(CultureInfo.InvariantCulture, "The number of file system objects: {0} is not equal than expected: {1}", expectedFso, fsoCount));
}
Console.WriteLine();
}
private void Path_CheckSupportedPathFormat_CatchNotSupportedException_PathContainsColon(bool isNetwork)
{
UnitTestConstants.PrintUnitTestHeader(isNetwork);
Console.WriteLine();
var gotException = false;
const string colonText = @"\My:FilePath";
var invalidPath = (isNetwork ? Alphaleonis.Win32.Filesystem.Path.LocalToUnc(UnitTestConstants.TempFolder) : UnitTestConstants.TempFolder + @"\dev\test") + colonText;
Console.WriteLine("Invalid Path: [{0}]", invalidPath);
try
{
Alphaleonis.Win32.Filesystem.Path.CheckSupportedPathFormat(invalidPath, true, true);
}
catch (Exception ex)
{
var exType = ex.GetType();
gotException = exType == typeof(NotSupportedException);
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();
}
