public void AlphaFS_Host_EnumerateNetworkConnections_Local_Success() { UnitTestConstants.PrintUnitTestHeader(false); var networkConnectionCount = 0; foreach (var networkConnection in Host.EnumerateNetworkConnections().OrderBy(networkConnection => networkConnection.NetworkInfo.Name)) { Console.WriteLine("#{0:000}\tNetwork: [{1}]", ++networkConnectionCount, networkConnection.NetworkInfo.Name); UnitTestConstants.Dump(networkConnection); UnitTestConstants.Dump(networkConnection.NetworkInfo, true); UnitTestConstants.Dump(networkConnection.NetworkInterface, true); Console.WriteLine(); } if (networkConnectionCount == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } }
public void AlphaFS_Host_EnumerateSessions_Local_Success() { UnitTestConstants.PrintUnitTestHeader(false); var host = Environment.MachineName; Console.WriteLine("Input Host: [{0}]", host); var sessionCount = 0; foreach (var sessionsInfo in Alphaleonis.Win32.Network.Host.EnumerateSessions(host)) { //Console.WriteLine("\n\t#{0:000}\tShare: [{1}]", ++cnt, shareInfo); UnitTestConstants.Dump(sessionsInfo); Assert.IsNotNull(sessionsInfo); sessionCount++; Console.WriteLine(); } if (sessionCount == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } }
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(); } }
public void AlphaFS_Volume_EnumerateVolumes_Local_Success() { UnitTestConstants.PrintUnitTestHeader(false); Console.WriteLine("Should give the same (or more) enumeration as \"mountvol.exe\"\n"); var volumeCount = 0; foreach (var volume in Alphaleonis.Win32.Filesystem.Volume.EnumerateVolumes()) { Console.WriteLine("#{0:000}\tVolume: [{1}]", ++volumeCount, volume); Console.WriteLine(); foreach (var displayName in Alphaleonis.Win32.Filesystem.Volume.EnumerateVolumePathNames(volume)) { Console.WriteLine("\t\tVolume points to logcal drive: [{0}]", displayName); Console.WriteLine(); } Console.WriteLine(); } if (volumeCount == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } }
public void AlphaFS_Host_EnumerateDfsLinks_Network_Success() { UnitTestConstants.PrintUnitTestHeader(true); var cnt = 0; var noDomainConnection = true; try { foreach (var dfsNamespace in Alphaleonis.Win32.Network.Host.EnumerateDomainDfsRoot()) { noDomainConnection = false; Console.Write("#{0:000}\tDFS Root: [{1}]\n", ++cnt, dfsNamespace); var cnt2 = 0; try { foreach (var dfsInfo in Alphaleonis.Win32.Network.Host.EnumerateDfsLinks(dfsNamespace).OrderBy(d => d.EntryPath)) { Console.Write("\n\t#{0:000}\tDFS Link: [{1}]", ++cnt2, dfsInfo.EntryPath); } } catch (NetworkInformationException ex) { Console.WriteLine("NetworkInformationException #1: [{0}]", ex.Message.Replace(Environment.NewLine, " ")); } catch (Exception ex) { Console.WriteLine("\nCaught (UNEXPECTED #1) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } Console.WriteLine(); } } catch (NetworkInformationException ex) { Console.WriteLine("NetworkInformationException #2: [{0}]", ex.Message.Replace(Environment.NewLine, " ")); } catch (Exception ex) { Console.WriteLine("\nCaught (UNEXPECTED #2) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } if (noDomainConnection) { UnitTestAssert.Inconclusive("Test ignored because the computer is either not connected to a domain or no DFS root exists."); } else if (cnt == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } Console.WriteLine(); }
private void AlphaFS_Directory_EncryptDecrypt(bool isNetwork) { using (var tempRoot = new TemporaryDirectory(isNetwork)) { var folder = tempRoot.CreateTree(); Console.WriteLine("Input Directory Path: [{0}]", folder.FullName); // Encrypt root folder only. Alphaleonis.Win32.Filesystem.Directory.Encrypt(folder.FullName); // Verify that the contents of the folder are still decrypted. var cnt = 0; foreach (var fsei in Alphaleonis.Win32.Filesystem.Directory.EnumerateFileSystemEntryInfos <Alphaleonis.Win32.Filesystem.FileSystemEntryInfo>(folder.FullName, Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive)) { cnt++; Assert.IsTrue((fsei.Attributes & System.IO.FileAttributes.Encrypted) == 0, "It is expected that the file system object is decrypted, but it is not."); } if (cnt == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } // Encrypt entire folder for decrypt test. Alphaleonis.Win32.Filesystem.Directory.Encrypt(folder.FullName, true); // Decrypt root folder only. Alphaleonis.Win32.Filesystem.Directory.Decrypt(folder.FullName); // Verify that the contents of the folder are still encrypted. cnt = 0; foreach (var fsei in Alphaleonis.Win32.Filesystem.Directory.EnumerateFileSystemEntryInfos <Alphaleonis.Win32.Filesystem.FileSystemEntryInfo>(folder.FullName, Alphaleonis.Win32.Filesystem.DirectoryEnumerationOptions.Recursive)) { cnt++; Assert.IsTrue((fsei.Attributes & System.IO.FileAttributes.Encrypted) != 0, "It is expected that the file system object is encrypted, but it is not."); } if (cnt == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } } Console.WriteLine(); }
public void AlphaFS_Volume_GetDriveNameForNtDeviceName_And_GetVolumeGuidForNtDeviceName_Local_Success() { UnitTestConstants.PrintUnitTestHeader(false); var logicalDriveCount = 0; foreach (var drive in System.IO.DriveInfo.GetDrives()) { // Skip mapped drives and network drives. if (drive.DriveType == System.IO.DriveType.NoRootDirectory || drive.DriveType == System.IO.DriveType.Network) { continue; } var driveName = drive.Name; var dosDeviceName = Alphaleonis.Win32.Filesystem.Volume.GetVolumeDeviceName(driveName); var deviceGuid = Alphaleonis.Win32.Filesystem.Volume.GetVolumeGuid(driveName); Console.WriteLine("#{0:000}\tInput Path: [{1}]", ++logicalDriveCount, dosDeviceName); var driveNameResult = Alphaleonis.Win32.Filesystem.Volume.GetDriveNameForNtDeviceName(dosDeviceName); Console.WriteLine("\n\tGetDriveNameForNtDeviceName() : [{0}]", driveNameResult ?? "null"); Assert.AreEqual(driveName, driveNameResult); var driveGuidResult = Alphaleonis.Win32.Filesystem.Volume.GetVolumeGuidForNtDeviceName(dosDeviceName); Console.WriteLine("\n\tGetVolumeGuidForNtDeviceName(): [{0}]\n", driveGuidResult ?? "null"); Assert.AreEqual(deviceGuid, driveGuidResult); } if (logicalDriveCount == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } }
public void AlphaFS_Volume_EnumerateVolumeMountPoints_Local_Success() { UnitTestAssert.IsElevatedProcess(); UnitTestConstants.PrintUnitTestHeader(false); var cnt = 0; Console.WriteLine("Logical Drives\n"); // Get Logical Drives from UnitTestConstants.Local Host, .IsReady Drives only. foreach (var drive in Alphaleonis.Win32.Filesystem.Directory.GetLogicalDrives(false, true)) { try { // Logical Drives --> Volumes --> Volume Mount Points. var uniqueVolName = Alphaleonis.Win32.Filesystem.Volume.GetUniqueVolumeNameForPath(drive); if (!Alphaleonis.Utils.IsNullOrWhiteSpace(uniqueVolName) && !uniqueVolName.Equals(drive, StringComparison.OrdinalIgnoreCase)) { foreach (var mountPoint in Alphaleonis.Win32.Filesystem.Volume.EnumerateVolumeMountPoints(uniqueVolName).Where(mp => !Alphaleonis.Utils.IsNullOrWhiteSpace(mp))) { string guid = null; try { guid = Alphaleonis.Win32.Filesystem.Volume.GetVolumeGuid(System.IO.Path.Combine(drive, mountPoint)); } catch (Exception ex) { Console.WriteLine("\n\tCaught (UNEXPECTED #1) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } Console.WriteLine("\t#{0:000}\tLogical Drive: [{1}]\tGUID: [{2}]\n\t\tDestination : [{3}]\n", ++cnt, drive, guid ?? "null", mountPoint); } } } catch (Exception ex) { Console.WriteLine("\n\tCaught (UNEXPECTED #2) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } } if (cnt == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } }
public void AlphaFS_Host_EnumerateDrives_Network_Success() { UnitTestAssert.IsElevatedProcess(); UnitTestConstants.PrintUnitTestHeader(true); var host = Environment.MachineName; var drives = Alphaleonis.Win32.Network.Host.EnumerateDrives(host, true).ToArray(); foreach (var driveInfo in drives) { Console.WriteLine("Host Local Drive: [{0}]", driveInfo.Name); UnitTestConstants.Dump(driveInfo); UnitTestConstants.Dump(driveInfo.DiskSpaceInfo, true); UnitTestConstants.Dump(driveInfo.VolumeInfo, true); Assert.IsNull(driveInfo.DosDeviceName); Assert.IsNull(driveInfo.VolumeInfo.Guid); Console.WriteLine(); } if (drives.Length == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } // \\localhost\C$ host = Alphaleonis.Win32.Network.Host.GetUncName() + Alphaleonis.Win32.Filesystem.Path.DirectorySeparator + UnitTestConstants.SysDrive[0] + Alphaleonis.Win32.Filesystem.Path.NetworkDriveSeparator + Alphaleonis.Win32.Filesystem.Path.DirectorySeparator; Assert.AreEqual(drives[0].Name, host); }
private void AlphaFS_Device_EnumerateDevices() { UnitTestConstants.PrintUnitTestHeader(false); var tempPath = Environment.MachineName; var classCnt = 0; foreach (var deviceClass in EnumMemberToList <Alphaleonis.Win32.Filesystem.DeviceGuid>()) { Console.WriteLine("#{0:000}\tClass: [{1}]", ++classCnt, deviceClass); foreach (var device in Alphaleonis.Win32.Filesystem.Device.EnumerateDevices(tempPath, deviceClass)) { UnitTestConstants.Dump(device); } Console.WriteLine(); } if (classCnt == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } }
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(); } }
public void AlphaFS_Volume_GetXxx_Local_Success() { UnitTestConstants.PrintUnitTestHeader(false); var deviceNamePrefix = Alphaleonis.Win32.Filesystem.Path.DevicePrefix + "HarddiskVolume"; var volumePrefix = Alphaleonis.Win32.Filesystem.Path.VolumePrefix + "{"; var logicalDriveCount = 0; foreach (var logicalDrive in System.IO.DriveInfo.GetDrives()) { Console.WriteLine("#{0:000}\tInput Logical Drive Path: [{1}]\n", ++logicalDriveCount, logicalDrive.Name); if (logicalDrive.DriveType == System.IO.DriveType.CDRom) { Console.WriteLine(); continue; } // GetVolumeDeviceName: "C:\" --> "\Device\HarddiskVolume4" var deviceNameFromLogicalDrive = Alphaleonis.Win32.Filesystem.Volume.GetVolumeDeviceName(logicalDrive.Name); Console.WriteLine("\tGetVolumeDeviceName\t\t\t: [{0}]", deviceNameFromLogicalDrive); Assert.IsNotNull(deviceNameFromLogicalDrive); // Skip mapped drives and network drives. if (logicalDrive.DriveType != System.IO.DriveType.NoRootDirectory && logicalDrive.DriveType != System.IO.DriveType.Network) { Assert.IsTrue(deviceNameFromLogicalDrive.StartsWith(deviceNamePrefix)); // GetVolumeGuid: "C:\" --> "\\?\Volume{db5044f9-bd1f-4243-ab97-4b985eb29e80}\" var volumeGuidFromLogicalDrive = Alphaleonis.Win32.Filesystem.Volume.GetVolumeGuid(logicalDrive.Name); Console.WriteLine("\tGetVolumeGuid\t\t\t\t: [{0}]", volumeGuidFromLogicalDrive); Assert.IsNotNull(volumeGuidFromLogicalDrive); Assert.IsTrue(volumeGuidFromLogicalDrive.StartsWith(volumePrefix)); // GetUniqueVolumeNameForPath: "C:\" --> "\\?\Volume{db5044f9-bd1f-4243-ab97-4b985eb29e80}\" var uniqueVolumeNameFromlDriveInputPath = Alphaleonis.Win32.Filesystem.Volume.GetUniqueVolumeNameForPath(logicalDrive.Name); Console.WriteLine("\tGetUniqueVolumeNameForPath\t: [{0}]", uniqueVolumeNameFromlDriveInputPath); Assert.IsNotNull(uniqueVolumeNameFromlDriveInputPath); Assert.IsTrue(uniqueVolumeNameFromlDriveInputPath.StartsWith(volumePrefix)); } // GetVolumePathName: "C:\" or "C:\Windows" --> "C:\" var volumePathNameFromLogicalDrive = Alphaleonis.Win32.Filesystem.Volume.GetVolumePathName(logicalDrive.Name); Console.WriteLine("\tGetVolumePathName\t\t\t: [{0}]\n", volumePathNameFromLogicalDrive); Assert.IsNotNull(volumePathNameFromLogicalDrive); Assert.AreEqual(logicalDrive.Name, volumePathNameFromLogicalDrive); } if (logicalDriveCount == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } }
public void AlphaFS_Host_EnumerateDfsRoot_Network_Success() { UnitTestConstants.PrintUnitTestHeader(true); var cnt = 0; var noDomainConnection = true; // Drill down to get servers from the first namespace retrieved. try { foreach (var dfsName in Alphaleonis.Win32.Network.Host.EnumerateDomainDfsRoot()) { noDomainConnection = false; Console.Write("#{0:000}\tDFS Root: [{1}]\n", ++cnt, dfsName); try { var dfsInfo = Alphaleonis.Win32.Network.Host.GetDfsInfo(dfsName); foreach (var storage in dfsInfo.StorageInfoCollection) { var cnt2 = 0; Console.Write("\n\tEnumerating DFS Namespaces from host: [{0}]\n", storage.ServerName); foreach (var dfsNamespace in Alphaleonis.Win32.Network.Host.EnumerateDfsRoot(storage.ServerName, true)) { Console.Write("\t#{0:000}\tDFS Root: [{1}]\n", ++cnt2, dfsNamespace); } } } catch (NetworkInformationException ex) { Console.WriteLine("NetworkInformationException #1: [{0}]", ex.Message.Replace(Environment.NewLine, " ")); } catch (Exception ex) { Console.WriteLine("\n\tCaught (UNEXPECTED #1) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } Console.WriteLine(); } if (cnt == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } } catch (NetworkInformationException ex) { Console.WriteLine("NetworkInformationException #2: [{0}]", ex.Message.Replace(Environment.NewLine, " ")); } catch (Exception ex) { Console.WriteLine("Caught (UNEXPECTED #2) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } if (noDomainConnection) { UnitTestAssert.Inconclusive("Test ignored because the computer is either not connected to a domain or no DFS root exists."); } else if (cnt == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } Console.WriteLine(); }
public void AlphaFS_DfsInfo() { var cnt = 0; var noDomainConnection = true; try { foreach (var dfsNamespace in Host.EnumerateDomainDfsRoot()) { noDomainConnection = false; try { Console.Write("\n#{0:000}\tDFS Root: [{1}]\n", ++cnt, dfsNamespace); var dfsInfo = Host.GetDfsInfo(dfsNamespace); UnitTestConstants.Dump(dfsInfo); Console.Write("\n\tNumber of Storages: [{0}]\n", dfsInfo.StorageInfoCollection.Count()); foreach (var store in dfsInfo.StorageInfoCollection) { UnitTestConstants.Dump(store); } Console.WriteLine(); } catch (NetworkInformationException ex) { Console.WriteLine("\n\tNetworkInformationException #1: [{0}]", ex.Message.Replace(Environment.NewLine, " ")); } catch (Exception ex) { Console.WriteLine("\n\t(1) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } } if (cnt == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } } catch (NetworkInformationException ex) { Console.WriteLine("\n\tNetworkInformationException #2: [{0}]", ex.Message.Replace(Environment.NewLine, " ")); } catch (Exception ex) { Console.WriteLine("\n\t(2) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } if (noDomainConnection) { UnitTestAssert.Inconclusive("Test ignored because the computer is either not connected to a domain or no DFS root exists."); } if (cnt == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } Console.WriteLine(); }
public void AlphaFS_Volume_GetUniqueVolumeNameForPath_Local_Success() { UnitTestConstants.PrintUnitTestHeader(false); var logicalDriveCount = 0; foreach (var driveInfo in System.IO.DriveInfo.GetDrives()) { // Skip mapped drives and network drives. if (driveInfo.DriveType == System.IO.DriveType.NoRootDirectory || driveInfo.DriveType == System.IO.DriveType.Network) { continue; } var driveName = driveInfo.Name; var deviceGuid = Alphaleonis.Win32.Filesystem.Volume.GetVolumeGuid(driveName); Console.WriteLine("#{0:000}\tInput Path: [{1}]", ++logicalDriveCount, driveName); var volumeNameResult = Alphaleonis.Win32.Filesystem.Volume.GetUniqueVolumeNameForPath(driveName); Console.WriteLine("\n\tGetUniqueVolumeNameForPath: [{0}]", volumeNameResult ?? "null"); // Typically, only one mount point exists so the Volume GUIDs will match. Assert.AreEqual(deviceGuid, volumeNameResult); var pathNames = Alphaleonis.Win32.Filesystem.Volume.EnumerateVolumePathNames(volumeNameResult).ToArray(); foreach (var uniqueName in pathNames) { Console.WriteLine("\n\tUnique name: [{0}]", uniqueName); try { var targetInfo = Alphaleonis.Win32.Filesystem.Directory.GetLinkTargetInfo(uniqueName); UnitTestConstants.Dump(targetInfo); Assert.AreEqual(deviceGuid, Alphaleonis.Win32.Filesystem.Path.LongPathPrefix + targetInfo.SubstituteName.Replace(Alphaleonis.Win32.Filesystem.Path.NonInterpretedPathPrefix, string.Empty)); } catch { if (!string.IsNullOrWhiteSpace(uniqueName)) { Assert.AreEqual(driveName, uniqueName); } } } Console.WriteLine(); } if (logicalDriveCount == 0) { UnitTestAssert.InconclusiveBecauseResourcesAreUnavailable(); } }