Exemple #1
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();
        }
Exemple #2
0
        public void AlphaFS_Path_GetShort83PathAndGetLongFrom83ShortPath_FromFile_LocalAndNetwork_Success()
        {
            var isDisabled = (int)Registry.GetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem", "NtfsDisable8dot3NameCreation", 0) > 0;

            if (isDisabled)
            {
                UnitTestAssert.Inconclusive("NtfsDisable8dot3NameCreation is disabled in registry.");
            }

            AlphaFS_Path_GetShort83PathAndGetLongFrom83ShortPath_FromFile(false);
            AlphaFS_Path_GetShort83PathAndGetLongFrom83ShortPath_FromFile(true);
        }
        public void AlphaFS_Host_EnumerateDomainDfsRoot_Network_Success()
        {
            UnitTestConstants.PrintUnitTestHeader(true);

            Console.Write("Enumerating DFS Root from user domain: [{0}]\n", Alphaleonis.Win32.Network.NativeMethods.ComputerDomain);

            var cnt = 0;
            var noDomainConnection = true;

            try
            {
                foreach (var dfsNamespace in Alphaleonis.Win32.Network.Host.EnumerateDomainDfsRoot())
                {
                    noDomainConnection = false;
                    Console.Write("\n\t#{0:000}\tDFS Root: [{1}]", ++cnt, dfsNamespace);
                }
            }
            catch (NetworkInformationException ex)
            {
                Console.WriteLine("NetworkInformationException: [{0}]", ex.Message.Replace(Environment.NewLine, "  "));
            }
            catch (Exception ex)
            {
                Console.WriteLine("\n\tCaught (UNEXPECTED) {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.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();
        }