Пример #1
0
        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, -21);

                UnitTestConstants.Dump(networkConnection.NetworkInfo, -21, true);

                UnitTestConstants.Dump(networkConnection.NetworkInterface, -20, true);


                Console.WriteLine();
            }


            if (networkConnectionCount == 0)
            {
                UnitTestAssert.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
Пример #2
0
        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);

                if (UnitTestConstants.Dump(sessionsInfo, -16))
                {
                    sessionCount++;
                }

                Console.WriteLine();
            }


            if (sessionCount == 0)
            {
                UnitTestAssert.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
        public void AlphaFS_Host_EnumerateOpenResources_Local_Success()
        {
            UnitTestAssert.IsElevatedProcess();
            UnitTestConstants.PrintUnitTestHeader(false);

            var host = Environment.MachineName;

            Console.WriteLine("Connected to Host: [{0}]", host);


            var count = 0;

            foreach (var openResourceInfo in Alphaleonis.Win32.Network.Host.EnumerateOpenResources(host, null, null, false))
            {
                UnitTestConstants.Dump(openResourceInfo);

                Assert.IsNotNull(openResourceInfo);

                count++;

                Console.WriteLine();
            }


            if (count == 0)
            {
                UnitTestAssert.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
Пример #4
0
        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.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
        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.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
Пример #6
0
        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))
            {
                if (UnitTestConstants.Dump(shareInfo, -18))
                {
                    count++;
                }

                Console.WriteLine();
            }

            if (count == 0)
            {
                UnitTestAssert.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
Пример #7
0
        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.InconclusiveBecauseEnumerationIsEmpty();
            }


            Console.WriteLine();
        }
Пример #8
0
        public void AlphaFS_Volume_GetUniqueVolumeNameForPath_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 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 displayName in pathNames)
                {
                    Console.WriteLine("\n\t(Input Volume GUID Path) EnumerateVolumePathNames: Volume points to logcal drive: [{0}]\n", displayName);


                    // Volumes don't always have drive letters.

                    if (!string.IsNullOrWhiteSpace(displayName))
                    {
                        Assert.AreEqual(driveName, displayName);
                    }
                }
            }


            if (logicalDriveCount == 0)
            {
                UnitTestAssert.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
        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.InconclusiveBecauseEnumerationIsEmpty();
                }


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

            Console.WriteLine();
        }
Пример #10
0
        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.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
Пример #11
0
        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.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
Пример #12
0
        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.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
Пример #13
0
        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.InconclusiveBecauseEnumerationIsEmpty();
            }
        }
Пример #14
0
        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.InconclusiveBecauseEnumerationIsEmpty();
                }
            }
            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.InconclusiveBecauseEnumerationIsEmpty();
            }

            Console.WriteLine();
        }
        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.InconclusiveBecauseEnumerationIsEmpty();
                }
            }
            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.InconclusiveBecauseEnumerationIsEmpty();
            }


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