NStub.Core.TestProjectBuilder.GenerateTests C# (CSharp) Méthode

        public void GenerateTests(
            string outputFolder,
            Type generatorType,
            string inputAssemblyPath,
            IList<TestNode> mainNodes,
            IList<AssemblyName> referencedAssemblies)
        {
            // string outputFolder = this._outputDirectoryTextBox.Text;
            // Type generatorType = (Type)cbGenerators.SelectedItem;
            // string inputAssemblyPath = this._inputAssemblyTextBox.Text;
            // //TreeNodeCollection mainNodes = this._assemblyGraphTreeView.Nodes;
            // IList<TreeNode> mainNodes = this._assemblyGraphTreeView.Nodes.Cast<TreeNode>().ToList();
            // IList<AssemblyName> referencedAssemblies = this._referencedAssemblies;
            if (this.logger != null)
            {
                this.logger("-----------------------------------------------------------------------------");
                this.logger("Generating Test Project '" + this.csharpProjectGenerator.ProjectName + "'");
                this.logger("-----------------------------------------------------------------------------");
            }

            // Create a new directory for each assembly
            foreach (var assemblyNode in mainNodes)
            {
                string calculatedOutputDirectory = outputFolder +
                                         this.sbs.DirectorySeparatorChar +
                                         this.sbs.GetFileNameWithoutExtension(assemblyNode.Text) +
                                         ".Tests";
                this.sbs.CreateDirectory(calculatedOutputDirectory);

                // Create our project generator

                // Add our referenced assemblies to the project generator so we
                // can build the resulting project
                foreach (AssemblyName assemblyName in referencedAssemblies)
                {
                    this.csharpProjectGenerator.ReferencedAssemblies.Add(assemblyName);
                }

                // Generate the new test namespace
                // At the assembly level
                foreach (var moduleNode in assemblyNode.Nodes)
                {
                    if (!moduleNode.Checked)
                    {
                        // continue;
                    }

                    // Create the namespace and initial inputs
                    var codeNamespace = new CodeNamespace();

                    // At the type level
                    foreach (var classNode in moduleNode.Nodes)
                    {
                        // TODO: This namespace isn't being set correctly.
                        // Also one namespace per run probably won't work, we may
                        // need to break this up more.
                        codeNamespace.Name =
                            Utility.GetNamespaceFromFullyQualifiedTypeName(classNode.Text);

                        if (!classNode.Checked)
                        {
                            continue;
                        }

                        Thread.Sleep(1);
                        if (this.logger != null)
                        {
                            this.logger("Building '" + classNode.Text + "'");
                        }

                        // Create the class
                        var testClass = new CodeTypeDeclaration(classNode.Text);
                        codeNamespace.Types.Add(testClass);
                        var testObjectClassType = classNode.ClrType;
                        testClass.UserData.Add(NStubConstants.UserDataClassTypeKey, testObjectClassType);

                        // At the method level
                        // Create a test method for each method in this type
                        foreach (var classmemberNode in classNode.Nodes)
                        {
                            if (!classmemberNode.Checked)
                            {
                                continue;
                            }

                            try
                            {
                                // Retrieve the MethodInfo object from this TreeNode's tag
                                // var memberInfo = (MethodInfo)rootsubsubsubnode.Tag;
                                var memberInfo = classmemberNode.MethodInfo;
                                CodeMemberMethod codeMemberMethod =
                                    this.CreateMethod(classmemberNode.Text, memberInfo);
                                codeMemberMethod.UserData.Add(NStubConstants.TestMemberMethodInfoKey, memberInfo);
                                testClass.Members.Add(codeMemberMethod);
                            }
                            catch (Exception ex)
                            {
                                // MessageBox.Show(ex.Message + Environment.NewLine + ex.ToString());
                                if (this.logger != null)
                                {
                                    this.logger(
                                        ex.Message + Environment.NewLine + ex + Environment.NewLine);
                                }
                            }
                        }
                    }

                    this.WriteTestFile(calculatedOutputDirectory, codeNamespace);
                }

                // Now write the project file and add all of the test files to it
                this.csharpProjectGenerator.GenerateProjectFile();
            }

            if (this.logger != null)
            {
                this.logger("-----------------------------------------------------------------------------");
                this.logger("Finished generating Project '" + this.csharpProjectGenerator.ProjectName + "'");
                this.logger("-----------------------------------------------------------------------------");
            }
        }