Ejemplo n.º 1
0
        private void SynchronizeWorkspaces(PostmanWorkspaces workspaces)
        {
            var directories = new DirectoryInfo(this.postmanConfiguration.LocalDirectory).GetDirectories();

            foreach (var workspace in workspaces.Workspaces)
            {
                if (directories.All(d => d.Name != workspace.Name))
                {
                    this.logger.LogInformation($"Create directory for workspace {workspace.Name}");
                    Directory.CreateDirectory(Path.Combine(this.postmanConfiguration.LocalDirectory, workspace.Name));
                }
            }

            foreach (var directory in directories)
            {
                if (directory.Name.StartsWith("."))
                {
                    continue;
                }

                if (workspaces.Workspaces.All(w => w.Name != directory.Name))
                {
                    this.logger.LogInformation($"Deleting directory for workspace {directory.Name}");
                    directory.Delete();
                }
            }
        }
Ejemplo n.º 2
0
        private bool VerifyDownloadFileNames(string[] expectedFileNames)
        {
            var fileNames = new DirectoryInfo(NewAppTestDir).GetFiles()
                            .Where(x => new[] { ".jpg", ".pdf" }.Contains(x.Extension.ToLower())).Select(x => Path.GetFileNameWithoutExtension(x.Name).Trim());

            var result = fileNames.All(x => expectedFileNames.Contains(x)) && expectedFileNames.All(x => fileNames.Contains(x));

            return(result);
        }
Ejemplo n.º 3
0
        public static bool CheckDir(string path)
        {
            Logger.DebugLog(string.Format("Check {0}", path));
            var files = new DirectoryInfo(path).GetFiles();

            foreach (var f in _files)
            {
                if (files.All(file => file.Name != f))
                {
                    return(false);
                }
            }

            return(true);
        }
Ejemplo n.º 4
0
        static public IEnumerable <string> CollectNupkgFolder(string folderName, int leaveFiles)
        {
            List <string> targetFolderList = new List <string>();

            var direcories = new DirectoryInfo(folderName).GetDirectories();

            if (direcories.Length > leaveFiles)
            {
                SemVersion versionInfo;

                if (direcories.All(x => SemVersion.TryParse(x.Name, out versionInfo)) == true)
                {
                    var removes = direcories.OrderBy(x => x.Name).SkipLast(leaveFiles).Select(x => x.FullName);
                    targetFolderList.AddRange(removes);
                }
            }

            return(targetFolderList);
        }
Ejemplo n.º 5
0
        public async Task CanLoadDatabaseAfterUsingVoronRecoveryOnItWithCopyOnWriteMode(bool compressed)
        {
            var dbPath             = NewDataPath(prefix: Guid.NewGuid().ToString());
            var recoveryExportPath = NewDataPath(prefix: Guid.NewGuid().ToString());

            DatabaseStatistics databaseStatistics;

            // create db with sample data
            using (var store = GetDocumentStore(new Options()
            {
                Path = dbPath,
                ModifyDatabaseRecord = record =>
                {
                    if (compressed)
                    {
                        record.DocumentsCompression = new DocumentsCompressionConfiguration
                        {
                            Collections = new[] { "Orders", "Employees", "Companies", "Products" },
                            CompressRevisions = true
                        };
                    }
                }
            }))
            {
                await CreateLegacyNorthwindDatabase(store);

                databaseStatistics = store.Maintenance.Send(new GetStatisticsOperation());
            }

            var journals = new DirectoryInfo(Path.Combine(dbPath, "Journals")).GetFiles();

            // run recovery
            using (var recovery = new Recovery(new VoronRecoveryConfiguration()
            {
                LoggingMode = Sparrow.Logging.LogMode.None,
                DataFileDirectory = dbPath,
                PathToDataFile = Path.Combine(dbPath, "Raven.voron"),
                OutputFileName = Path.Combine(recoveryExportPath, "recovery.ravendump"),
            }))
            {
                recovery.Execute(TextWriter.Null, CancellationToken.None);
            }

            // make sure no journal file was lost during the process - by default we use copy on write mode
            var journalsAfterRecovery = new DirectoryInfo(Path.Combine(dbPath, "Journals")).GetFiles();

            Assert.Equal(journals.Length, journalsAfterRecovery.Length);
            Assert.True(journals.All(x => journalsAfterRecovery.Any(y => y.Name == x.Name)));

            // let's open the database
            using (var store = GetDocumentStore(new Options()
            {
                Path = dbPath
            }))
            {
                var currentStats = store.Maintenance.Send(new GetStatisticsOperation());

                Assert.Equal(databaseStatistics.CountOfAttachments, currentStats.CountOfAttachments);
                Assert.Equal(databaseStatistics.CountOfDocuments, currentStats.CountOfDocuments);
            }

            // let's import the recovery files

            using (var store = GetDocumentStore())
            {
                var op = await store.Smuggler.ImportAsync(new DatabaseSmugglerImportOptions()
                {
                }, Path.Combine(recoveryExportPath, "recovery-2-Documents.ravendump"));

                op.WaitForCompletion(TimeSpan.FromMinutes(2));

                var currentStats = store.Maintenance.Send(new GetStatisticsOperation());

                // + 1 as recovery adds some artificial items
                Assert.Equal(databaseStatistics.CountOfAttachments + 1, currentStats.CountOfAttachments);
                Assert.Equal(databaseStatistics.CountOfDocuments + 1, currentStats.CountOfDocuments);
            }
        }
Ejemplo n.º 6
0
        private void btnLinq_Click(object sender, RoutedEventArgs e)
        {
            // 2867
            IEnumerable <FileInfo> list = new DirectoryInfo
                                              (@"c:\windows\system32").GetFiles("*.*");

            // Where
            var soloDll1 = from f in list where filtroPerDll(f) select f;
            var soloDll2 = list.Where(filtroPerDll);

            // list.Count() > 0
            if (list != null && list.Any())
            {
            }

            var filtroDaConfig = list
                                 .Where(f => f.Extension == ConfigurationManager.AppSettings["Extension"])
                                 .ToList();

            // Ne esiste almeno uno che....è più grande di 50K?
            bool     esiste50K     = list.Any(f => f.Length > 50 * 1024);
            FileInfo file50K       = list.FirstOrDefault(f => f.Length > 50000 * 1024);
            bool     esistonoTutti = list
                                     .All(f => f.CreationTime.Year < 2015 && !f.IsReadOnly);

            var xyz = list
                      //.Where(f => f.CreationTime.Year < 2015)
                      //.Where(f => !f.IsReadOnly)
                      .Where(f => f.Extension == ".exe")
                      .Average(f => f.Length)
                      .ToString() + " bytes";

            int soloNascosti1 = list
                                .Count(f => f.Attributes == FileAttributes.Hidden);
            int soloNascosti2 = list
                                .Where(f => f.Attributes == FileAttributes.Hidden)
                                .Count();
            FileInfo fi = list.ElementAtOrDefault(50000);


            var fileOrdinati = list
                               .Where(f => f.Name.Contains("p"))
                               .ToList()
                               .OrderBy(f => f.Name)
                               .ThenBy(f => f.Length)
                               .ThenByDescending(f => f.DirectoryName);



            int elementPerPage = 20;

            var primaPagina = list.Skip(40)
                              .Take(elementPerPage)
                              .ToList();

            var toolbar = list.TakeWhile(f => f.Extension != ".ini")
                          .Select(f => new TemplateButton
            {
                Etichetta = f.Name,
                Colore    = "Red",
                Big       = f.Length > 500000
            })
                          .ToList();

            List <IGrouping <string, FileInfo> > raggruppati =
                list.GroupBy(f => f.Extension).ToList();

            foreach (IGrouping <string, FileInfo> item in raggruppati)
            {
                // Key contiene l'estensione
                string ext = item.Key;

                foreach (FileInfo file in item)
                {
                }
            }

            var token = new CancellationTokenSource();
            // PLINQ
            var ricerca = list.AsParallel()
                          .WithDegreeOfParallelism(2)
                          .WithCancellation(token.Token)
                          .Where(f => f.Name.Contains("ll"))
                          .ToList();

            token.Cancel();

            this.toolbar.ItemsSource = toolbar;

            if (file50K != null)
            {
            }

            foreach (var item in soloDll2)
            {
            }

            // Metodi di materializzazione (anche delle liste)
            // ToList()
            // FirstOrDefault()
            // First()
            // LastOrDefault()
            // Last()
            // SingleOrDefault()
            // Single()
            // Any()
        }
Ejemplo n.º 7
0
        private static void GenerateAllSolutions(GenerationMethod a_method)
        {
            System.Console.WriteLine();
            System.Console.WriteLine("Generating solutions...");
            System.Console.WriteLine();

            string dir = Directories.SolutionTrees + Path.DirectorySeparatorChar + "All";

            new DirectoryInfo(dir).CreateOrEmpty();

            FileInfo[] files1 = new DirectoryInfo(Directories.Examples).GetFiles(FileExtensions.XmlZipMask);
            FileInfo[] files2 = new DirectoryInfo(Directories.SolutionTrees).GetFiles(FileExtensions.XmlZipMask);

            var not_all = (from file1 in files1
                           where files2.Count(fi => Directories.ConvertName(fi.FullName) == file1.Name) < 4
                           select file1).ToArray();

            var too_much = (from file2 in files2
                            where files1.All(fi => fi.Name != Directories.ConvertName(file2.Name))
                            select file2).ToArray();


            if (not_all.Count() > 0)
            {
                System.Console.WriteLine("Is in 'Examples', but not in 'SolutionTrees' (run project 'SudokuGenerator'): " + not_all.First().FullName);
                System.Console.ReadKey(true);
                return;
            }

            if (too_much.Count() > 0)
            {
                System.Console.WriteLine("Is in 'SolutionTrees', but not in 'Examples': " + too_much.First().FullName);
                System.Console.ReadKey(true);
                return;
            }

            FileInfo[] files = (from file in new DirectoryInfo(Directories.SolutionTrees).GetFiles(FileExtensions.XmlZipMask)
                                group file by Directories.ConvertName(file.Name) into gr
                                select gr.First()).ToArray();

            ShowProgress(0, 70);

            ConcurrentCounter counter = new ConcurrentCounter();

            Parallel.ForEach(files, (file) =>
            {
                SudokuSolutionNode root = SudokuSolutionNode.LoadFromFile(file.FullName);

                string file_name = Path.GetFileNameWithoutExtension(Directories.ConvertName(file.Name));

                Dictionary <SudokuSolutionType, int> counters = new Dictionary <SudokuSolutionType, int>();
                Dictionary <SudokuSolutionType, List <SudokuSolutionNode> > lists = new Dictionary <SudokuSolutionType, List <SudokuSolutionNode> >();

                foreach (var type in Enum.GetValues(typeof(SudokuSolutionType)).Cast <SudokuSolutionType>())
                {
                    if (type == SudokuSolutionType.MarkImpossibles)
                    {
                        continue;
                    }
                    if (type == SudokuSolutionType.MarkSolved)
                    {
                        continue;
                    }
                    if (type == SudokuSolutionType.SinglesInUnit)
                    {
                        continue;
                    }

                    new DirectoryInfo(dir + Path.DirectorySeparatorChar + type).CreateOrEmpty();
                    lists[type]    = new List <SudokuSolutionNode>();
                    counters[type] = 1;
                }

                foreach (var list in lists.Values)
                {
                    list.Clear();
                }

                foreach (SudokuSolutionNode node in root.GetAllNodesEnumerator())
                {
                    if (node.State != SudokuSolutionNodeState.State)
                    {
                        continue;
                    }

                    var nodes = (from n in node.Nodes
                                 where (n.Solution.Type != SudokuSolutionType.MarkImpossibles) &&
                                 (n.Solution.Type != SudokuSolutionType.MarkSolved) &&
                                 (n.Solution.Type != SudokuSolutionType.SinglesInUnit)
                                 select n).ToList();

                    var sols = SudokuSolutionNode.FilterByOptions(nodes.Select(n => n.Solution).ToList());

                    var nodes_gr = (from n in nodes
                                    where sols.Contains(n.Solution)
                                    group n by n.Solution.Type into gr
                                    select gr.ToList()).ToList();


                    if ((a_method == GenerationMethod.OneType) || (a_method == GenerationMethod.OneSolution))
                    {
                        bool one_type = nodes_gr.Count(gr => gr.Any()) == 1;

                        if (!one_type)
                        {
                            continue;
                        }
                    }

                    if (a_method == GenerationMethod.OneSolution)
                    {
                        bool one_solution = nodes_gr.Count(gr => gr.Count == 1) == 1;

                        if (!one_solution)
                        {
                            continue;
                        }
                    }

                    foreach (var n in nodes)
                    {
                        lists[n.Solution.Type].Add(n);
                    }
                }

                foreach (var list in lists.Values)
                {
                    var uniques = from n in list
                                  group n by n.Solution into gr
                                  select gr.First();

                    var exclude = from n1 in uniques
                                  from n2 in uniques
                                  where !Object.ReferenceEquals(n1, n2) &&
                                  n1.Solution.Removed.Contains(n2.Solution.Removed, Comparators.SudokuNumberRowColComparer.Instance) &&
                                  n1.Solution.Stayed.Contains(n2.Solution.Stayed, Comparators.SudokuNumberRowColComparer.Instance) &&
                                  n1.Solution.ColorUnits.Equals(n2.Solution.ColorUnits)
                                  select n2;

                    var sols = uniques.Except(exclude);

                    foreach (var n in sols)
                    {
                        SudokuIntermediateSolution intermediate_solution = new SudokuIntermediateSolution(n.Board, n.NextBoard, n.Solution);

                        intermediate_solution.SaveToFile(dir + Path.DirectorySeparatorChar + n.Solution.Type + Path.DirectorySeparatorChar +
                                                         file_name + " - " + counters[n.Solution.Type]++ + FileExtensions.XmlZipExt);
                    }
                }

                counter.Increment();
                lock (counter)
                {
                    ShowProgress(counter.Value * 70 / files.Length, 70);
                }
            });
        }
Ejemplo n.º 8
0
        public async Task CanLoadDatabaseAfterUsingVoronRecoveryOnItWithCopyOnWriteMode()
        {
            var dbPath             = NewDataPath(prefix: Guid.NewGuid().ToString());
            var recoveryExportPath = NewDataPath(prefix: Guid.NewGuid().ToString());

            DatabaseStatistics databaseStatistics;

            // create db with sample data
            using (var store = GetDocumentStore(new Options()
            {
                Path = dbPath
            }))
            {
                store.Maintenance.Send(new CreateSampleDataOperation());

                databaseStatistics = store.Maintenance.Send(new GetStatisticsOperation());
            }

            var journals = new DirectoryInfo(Path.Combine(dbPath, "Journals")).GetFiles();

            // run recovery
            using (var recovery = new Recovery(new VoronRecoveryConfiguration()
            {
                DataFileDirectory = dbPath,
                PathToDataFile = Path.Combine(dbPath, "Raven.voron"),
                OutputFileName = Path.Combine(recoveryExportPath, "recovery.ravendump"),
            }))
            {
                recovery.Execute(CancellationToken.None);
            }

            // make sure no journal file was lost during the process - by default we use copy on write mode
            var journalsAfterRecovery = new DirectoryInfo(Path.Combine(dbPath, "Journals")).GetFiles();

            Assert.Equal(journals.Length, journalsAfterRecovery.Length);
            Assert.True(journals.All(x => journalsAfterRecovery.Any(y => y.Name == x.Name)));

            // let's open the database
            using (var store = GetDocumentStore(new Options()
            {
                Path = dbPath
            }))
            {
                var currentStats = store.Maintenance.Send(new GetStatisticsOperation());

                Assert.Equal(databaseStatistics.CountOfAttachments, currentStats.CountOfAttachments);
                Assert.Equal(databaseStatistics.CountOfDocuments, currentStats.CountOfDocuments);
            }

            // let's import the recovery files

            using (var store = GetDocumentStore())
            {
                var op = await store.Smuggler.ImportAsync(new DatabaseSmugglerImportOptions()
                {
                }, Path.Combine(recoveryExportPath, "recovery-2-Documents.ravendump"));

                op.WaitForCompletion(TimeSpan.FromMinutes(2));

                var currentStats = store.Maintenance.Send(new GetStatisticsOperation());

                // + 1 as recovery adds some artificial items
                Assert.Equal(databaseStatistics.CountOfAttachments + 1, currentStats.CountOfAttachments);
                Assert.Equal(databaseStatistics.CountOfDocuments + 1, currentStats.CountOfDocuments);
            }
        }
Ejemplo n.º 9
0
        private static void Main(string[] args)
        {
            try
            {
                var argset = new HashSet <string>(args);

                bool wantTools = (args.Any() && argset.Contains("-t"));
                bool wantReg   = (args.Any() && argset.Contains("-r"));

                Console.WriteLine($"Analysing Visual Studio installations - use -t on the command line to check for tools.");
                Console.WriteLine();
                Console.WriteLine("User local appdata entries for Visual Studio");

                var privateRegistryList = new List <string>();

                var userDirs = Directory.GetDirectories(@"c:\users");
                foreach (var dir in userDirs)
                {
                    var userPath = $@"{dir}\appdata\local\microsoft\visualstudio\";
                    if (Directory.Exists(userPath))
                    {
                        var directories = Directory.GetDirectories(userPath);
                        var nameList    = directories.Where(x => Regex.Match(new DirectoryInfo(x).Name, vsDirPattern, RegexOptions.IgnoreCase).Success);
                        foreach (var entry in nameList)
                        {
                            var  privateRegPath = Path.Combine(entry, "privateregistry.bin");
                            bool exists         = File.Exists(privateRegPath);
                            var  reportName     = exists ? "privateregistry.bin" : "";
                            Console.WriteLine($"    {entry} {reportName}");
                            if (exists)
                            {
                                privateRegistryList.Add(privateRegPath);
                            }
                        }
                    }
                }

                var vsProgramDataFolder = @"C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances";

                Console.WriteLine();
                Console.WriteLine(@"c:\programdata entries representing VS instances:");
                var dirs         = Directory.GetDirectories(vsProgramDataFolder);
                var instanceDirs = dirs.Where(x => Regex.Match(new DirectoryInfo(x).Name, vsProgDataDirPattern, RegexOptions.IgnoreCase).Success);
                foreach (var dir in instanceDirs)
                {
                    Console.WriteLine($"    {dir}");
                }

                Console.WriteLine();
                Console.WriteLine(@"c:\programdata details for VS instances (from the state.json file):");
                foreach (var dir in instanceDirs)
                {
                    var stateFile = Path.Combine(dir, "state.json");
                    Console.WriteLine($"    {stateFile}");
                    if (File.Exists(stateFile))
                    {
                        using (StreamReader reader = File.OpenText(stateFile))
                        {
                            JObject vsJsonInfo = (JObject)JToken.ReadFrom(new JsonTextReader(reader));

                            var topLevelInfoObjects = new[] { "installationPath", "installDate", "updateDate", "layoutPath", "installationVersion" };
                            foreach (var tlObject in topLevelInfoObjects)
                            {
                                var value = vsJsonInfo[tlObject] ?? $"NOT FOUND IN {stateFile}";
                                Console.WriteLine($"        {tlObject} - {value}");
                            }
                        }
                    }
                    Console.WriteLine();
                }

                Console.WriteLine(@"Checking c:\program files (x86)\Microsoft Visual Studio");
                var progDirs = Directory.GetDirectories(@"c:\program files (x86)\Microsoft Visual Studio");
                var dirList  = new List <string>();
                foreach (var dir in progDirs)
                {
                    var lastPart = new DirectoryInfo(dir).Name;
                    if (lastPart.All(char.IsDigit))
                    {
                        var year = Convert.ToInt32(lastPart);
                        if (year > 2015 && year < 2140)
                        {
                            dirList.Add(dir);
                        }
                    }
                }

                foreach (var dir in dirList)
                {
                    var subDirs = Directory.GetDirectories(dir);
                    foreach (var subDir in subDirs)
                    {
                        Console.WriteLine($"    {subDir}");
                    }
                }

                Console.WriteLine();
                Console.WriteLine("Printing registry uninstall entries:");
                var regUninstallEntries = new List <RegUninstallEntry>();
                RegUnInstall.GetProgEntries(regUninstallEntries);
                foreach (var entry in regUninstallEntries)
                {
                    Console.WriteLine($"   RegKey: {entry.Key}");
                    Console.WriteLine($"   DisplayName: {entry.DisplayName}");
                    Console.WriteLine($"   DisplayVersion: {entry.DisplayVersion}");
                    Console.WriteLine($"   InstallDate: {entry.InstallDate:yyyy-MM-dd}");
                    Console.WriteLine($"   InstallLocation: {entry.InstallLocation}");
                    Console.WriteLine($"   ModifyPath: {entry.ModifyPath}");
                    Console.WriteLine($"   RepairPath: {entry.RepairPath}");
                    Console.WriteLine($"   UninstallString: {entry.UninstallString}");
                    Console.WriteLine();
                }


                // we might not want to find exe tools because it could take a while, so get out if we don't:
                if (wantTools)
                {
                    Console.WriteLine();

                    // the list of tools (executables) we are looking for.
                    var toolList = new HashSet <string>(StringComparer.OrdinalIgnoreCase)
                    {
                        "cl", "csc", "link", "lib", "csc", "msbuild", "devenv", "dumpbin"
                    };
                    Console.WriteLine($"Checking for tools: {string.Join(" ", toolList.Select(x => x + ".exe"))}");

                    var toolsFound = new List <string>();
                    var fileStack  = new Stack <string>();
                    foreach (var dir in dirList)
                    {
                        fileStack.Push(dir);
                    }

                    // depth first search over filesystem under the program files directories we found earlier for
                    // visual studio installations:
                    while (fileStack.Any())
                    {
                        var nextDir = fileStack.Pop();
                        var files   = Directory.GetFiles(nextDir);
                        foreach (var file in files)
                        {
                            var name = Path.GetFileNameWithoutExtension(file);
                            var ext  = Path.GetExtension(file);
                            if (ext == ".exe" && toolList.Contains(name))
                            {
                                toolsFound.Add(file);
                            }
                        }
                        var directories = Directory.GetDirectories(nextDir);
                        foreach (var dir in directories)
                        {
                            fileStack.Push(dir);
                        }
                    }

                    toolsFound.ForEach(x => Console.WriteLine($"    {x}"));
                }
                if (wantReg)
                {
                    ProcessReg.Process(privateRegistryList);
                }
            }
            catch (Exception ex)
            {
                var fullname = System.Reflection.Assembly.GetEntryAssembly().Location;
                var progname = Path.GetFileNameWithoutExtension(fullname);
                Console.Error.WriteLine(progname + ": Error: " + ex.Message);
            }
        }
Ejemplo n.º 10
0
        public void Test_Solution_Trees_vs_Examples()
        {
            ProgressIndicator pi = new ProgressIndicator(System.Reflection.MethodBase.GetCurrentMethod().Name);

            FileInfo[] files1 = new DirectoryInfo(Directories.Examples).GetFiles(FileExtensions.XmlZipMask);
            FileInfo[] files2 = new DirectoryInfo(Directories.SolutionTrees).GetFiles(FileExtensions.XmlZipMask);

            var not_all = (from file1 in files1
                           where files2.Count(fi => Directories.ConvertName(fi.FullName) == file1.Name) < 4
                           select file1).ToArray();

            var too_much = (from file2 in files2
                            where files1.All(fi => fi.Name != Directories.ConvertName(file2.Name))
                            select file2).ToArray();

            if (not_all.Count() > 0)
            {
                Assert.Fail("Is in 'Examples', but not in 'SolutionTrees' (run project 'SudokuGenerator'): " +
                            not_all.First().FullName);
            }

            if (too_much.Count() > 0)
            {
                Assert.Fail("Is in 'SolutionTrees', but not in 'Examples': " + too_much.First().FullName);
            }

            string dir3 = Directories.SolutionTrees + Path.DirectorySeparatorChar + "Diffrencies";

            new DirectoryInfo(dir3).CreateOrEmpty();

            string dir4 = Directories.SolutionTrees + Path.DirectorySeparatorChar + "Diffrencies" +
                          Path.DirectorySeparatorChar + "Added";

            new DirectoryInfo(dir4).CreateOrEmpty();

            string dir5 = Directories.SolutionTrees + Path.DirectorySeparatorChar + "Diffrencies" +
                          Path.DirectorySeparatorChar + "Removed";

            new DirectoryInfo(dir5).CreateOrEmpty();

            bool b = false;

            ConcurrentBag <string> list = new ConcurrentBag <string>();

            ConcurrentCounter counter = new ConcurrentCounter();

            Parallel.ForEach(files2, (file2, state) =>
            {
                counter.Increment();
                pi.AddLine((counter.Value * 100 / files2.Length).ToString());

                SudokuSolutionNode node2 = SudokuSolutionNode.LoadFromFile(file2.FullName);

                SudokuBoard board = SudokuBoard.LoadFromFile(files1.First(f => f.Name ==
                                                                          Directories.ConvertName(file2.FullName)).FullName);

                board = board.Rotate(ExtractRotateNumber(file2.Name));

                SudokuSolutionNode node1 = SudokuSolutionNode.CreateRoot(board);
                node1.SolveWithStepAll();

                Assert.AreEqual(node1.State, node2.State, file2.FullName);
                Assert.AreEqual(node1.Board, node2.Board, file2.FullName);
                Assert.AreEqual(node1.Solution, node2.Solution, file2.FullName);

                b |= CompareNodes(node1, node2, file2, list, 1, 1);
            });

            if (list.Count != 0)
            {
                string filename = dir3 + Path.DirectorySeparatorChar + "!Diffrencies.txt";

                using (FileStream fs = new FileStream(filename, FileMode.Create))
                {
                    StreamWriter sw = new StreamWriter(fs);
                    list.ForEach(s => sw.WriteLine(s));
                    sw.Flush();
                }

                TestContext.AddResultFile(filename);
            }

            Assert.IsFalse(b);
        }