C# SharedProject.ProjectDefinition类代码示例

        private void MoveToMissingFolder(MoveDelegate mover) {
            foreach (var projectType in ProjectTypes) {
                var testDef = new ProjectDefinition("MoveToMissingFolder",
                    projectType,
                    PropertyGroup(
                        Property("ProjectView", "ShowAllFiles")
                    ),
                    ItemGroup(
                        Folder("Fob", isExcluded: false, isMissing: true),
                        Compile("codefile", isExcluded: false)
                    )
                );

                using (var solution = testDef.Generate().ToVs()) {
                    mover(
                        solution,
                        solution.FindItem("MoveToMissingFolder", "Fob"),
                        solution.FindItem("MoveToMissingFolder", "codefile" + projectType.CodeExtension)
                    );

                    solution.AssertFileDoesntExist("MoveToMissingFolder", "codefile" + projectType.CodeExtension);
                    solution.AssertFileExists("MoveToMissingFolder", "Fob", "codefile" + projectType.CodeExtension);
                }
            }
        }

        public void CutRenamePaste() {
            foreach (var projectType in ProjectTypes) {
                var testDef = new ProjectDefinition("DragDropCopyCutPaste",
                    projectType,
                    ItemGroup(
                        Folder("CutRenamePaste"),
                        Compile("CutRenamePaste\\CutRenamePaste")
                    )
                );

                using (var solution = testDef.Generate().ToMockVs()) {
                    var project = solution.WaitForItem("DragDropCopyCutPaste");
                    var file = solution.WaitForItem("DragDropCopyCutPaste", "CutRenamePaste", "CutRenamePaste" + projectType.CodeExtension);

                    file.Select();
                    solution.ControlX();

                    file.Select();
                    solution.Type(Key.F2);
                    solution.Type("CutRenamePasteNewName");
                    solution.Type(Key.Enter);

                    solution.Sleep(1000);
                    project.Select();
                    solution.ControlV();

                    solution.CheckMessageBox("The source URL 'CutRenamePaste" + projectType.CodeExtension + "' could not be found.");
                }
            }
        }

        public void ShowAllFilesSymLinks() {
            foreach (var projectType in ProjectTypes) {
                var def = new ProjectDefinition(
                    "ShowAllFilesSymLink",
                    projectType,
                    Folder("SubFolder")
                );
                var userDef = new ProjectDefinition(
                    def.Name,
                    projectType,
                    true,
                    Property("ProjectView", "ShowAllFiles")
                );

                var solutionFile = SolutionFile.Generate(def.Name, def, userDef);

                using (System.Diagnostics.Process p = System.Diagnostics.Process.Start("cmd.exe",
                    String.Format("/c mklink /J \"{0}\" \"{1}\"",
                        Path.Combine(solutionFile.Directory, @"ShowAllFilesSymLink\SymFolder"),
                        Path.Combine(solutionFile.Directory, @"ShowAllFilesSymLink\SubFolder")
                    ))) {
                    p.WaitForExit();
                }

                using (System.Diagnostics.Process p = System.Diagnostics.Process.Start("cmd.exe",
                    String.Format("/c mklink /J \"{0}\" \"{1}\"",
                        Path.Combine(solutionFile.Directory, @"ShowAllFilesSymLink\SubFolder\Infinite"),
                        Path.Combine(solutionFile.Directory, @"ShowAllFilesSymLink\SubFolder")
                    ))) {
                    p.WaitForExit();
                }

                try {
                    using (var solution = solutionFile.ToVs()) {
                        Assert.IsNotNull(solution.WaitForItem("ShowAllFilesSymLink", "SymFolder"));

                        // https://pytools.codeplex.com/workitem/1150 - infinite links, not displayed
                        Assert.IsNull(solution.FindItem("ShowAllFilesSymLink", "SubFolder", "Infinite"));

                        File.WriteAllText(
                            Path.Combine(solutionFile.Directory, @"ShowAllFilesSymLink\SubFolder\Foo.txt"),
                            "Hi!"
                        );

                        // https://pytools.codeplex.com/workitem/1152 - watching the sym link folder
                        Assert.IsNotNull(solution.WaitForItem("ShowAllFilesSymLink", "SubFolder", "Foo.txt"));
                        Assert.IsNotNull(solution.WaitForItem("ShowAllFilesSymLink", "SymFolder", "Foo.txt"));
                    }
                } finally {
                    using (System.Diagnostics.Process p = System.Diagnostics.Process.Start("cmd.exe",
                        String.Format("/c rmdir \"{0}\" \"{1}\"",
                            Path.Combine(solutionFile.Directory, @"ShowAllFilesSymLink\SymFolder"),
                            Path.Combine(solutionFile.Directory, @"ShowAllFilesSymLink\SubFolder\Infinite")
                        ))) {
                        p.WaitForExit();
                    }
                }
            }
        }

        // Currently Fails: https://pytools.codeplex.com/workitem/2609
        public void MoveFolderWithItem() {
            using (var app = new VisualStudioApp()) {

                // close any projects before switching source control...
                app.Dte.Solution.Close();

                app.SelectSourceControlProvider("Test Source Provider");

                ExpectSourceControl();

                foreach (var projectType in ProjectTypes) {
                    var testDef = new ProjectDefinition("SourceControl", projectType,
                        PropertyGroup(
                            Property("SccProjectName", "HelloWorld"),
                            Property("SccLocalPath", "LocalPath"),
                            Property("SccAuxPath", "AuxPath"),
                            Property("SccProvider", "TestProvider")
                        ),
                        ItemGroup(
                            Folder("Fob"),
                            Folder("Fob\\Oar"),
                            Compile("Program"),
                            Compile("Fob\\Oar\\Quox")
                        )
                    );

                    using (var solution = testDef.Generate()) {
                        TestSccProvider.DocumentEvents.Clear();

                        var project = app.OpenProject(solution.Filename);
                        var window = app.OpenSolutionExplorer();
                        
                        var folder = window.WaitForItem("Solution 'SourceControl' (1 project)", "SourceControl", "Fob", "Oar");
                        var point = folder.GetClickablePoint();
                        Mouse.MoveTo(point);
                        Mouse.Down(MouseButton.Left);

                        var destFolder = window.WaitForItem("Solution 'SourceControl' (1 project)", "SourceControl");
                        Mouse.MoveTo(destFolder.GetClickablePoint());
                        Mouse.Up(MouseButton.Left);

                        window.AssertFileExists(Path.GetDirectoryName(solution.Filename), "Solution 'SourceControl' (1 project)", "SourceControl", "Oar", "Quox" + projectType.CodeExtension);
                        var projectDir = Path.GetDirectoryName(project.FullName);
                        AssertDocumentEvents(projectDir,
                            OnQueryRenameFiles(projectType.Code("Fob\\Oar\\Quox"), projectType.Code("Oar\\Quox"), VSQUERYRENAMEFILEFLAGS_NoFlags),
                            OnQueryRenameFiles("Fob\\Oar\\", "Oar", VSQUERYRENAMEFILEFLAGS_Directory),
                            OnAfterRenameFiles(projectType.Code("Fob\\Oar\\Quox"), projectType.Code("Oar\\Quox"), VSRENAMEFILEFLAGS_NoFlags),
                            OnAfterRenameFiles("Fob\\Oar\\", "Oar", VSRENAMEFILEFLAGS_Directory)
                        );
                    }
                }
            }
        }

        public void RunWithoutStartupFile() {
            foreach (var projectType in ProjectTypes) {
                var testDef = new ProjectDefinition("RunWithoutStartupFile", projectType);

                using (var solution = testDef.Generate().ToVs()) {
                    solution.OpenDialogWithDteExecuteCommand("Debug.Start");
                    solution.CheckMessageBox("startup file");

                    solution.OpenDialogWithDteExecuteCommand("Debug.StartWithoutDebugging");
                    solution.CheckMessageBox("startup file");
                }
            }
        }

        /// <summary>
        /// Cut item, paste into folder, paste into top-level, 2nd paste should prompt for overwrite
        /// </summary>
        private void MultiPaste(MoveDelegate mover) {
            foreach (var projectType in ProjectTypes) {
                var testDef = new ProjectDefinition("HelloWorld",
                    projectType,
                    ItemGroup(
                        Compile("server"),
                        Compile("server2"),
                        Folder("SubFolder")
                    )
                );

                using (var solution = testDef.Generate().ToVs()) {
                    var server = solution.WaitForItem("HelloWorld", "server" + projectType.CodeExtension);
                    var server2 = solution.WaitForItem("HelloWorld", "server2" + projectType.CodeExtension);

                    mover(
                        solution,
                        solution.WaitForItem("HelloWorld", "SubFolder"),
                        solution.WaitForItem("HelloWorld", "server" + projectType.CodeExtension),
                        solution.WaitForItem("HelloWorld", "server2" + projectType.CodeExtension)
                    );

                    // paste once, multiple items should be pasted
                    Assert.IsNotNull(solution.WaitForItem("HelloWorld", "SubFolder", "server" + projectType.CodeExtension));
                    Assert.IsNotNull(solution.WaitForItem("HelloWorld", "SubFolder", "server2" + projectType.CodeExtension));

                    solution.SelectSolutionNode();

                    mover(
                        solution,
                        solution.WaitForItem("HelloWorld", "SubFolder"),
                        solution.WaitForItem("HelloWorld", "server" + projectType.CodeExtension),
                        solution.WaitForItem("HelloWorld", "server2" + projectType.CodeExtension)
                    );

                    // paste again, we should get the replace prompts...
                    using (var dialog = solution.WaitForOverwriteFileDialog()) {
                        dialog.Cancel();
                    }

                    // https://pytools.codeplex.com/workitem/1154
                    // and we shouldn't get a second dialog after cancelling...
                    solution.WaitForDialogDismissed();
                }
            }
        }

        public void ShowAllFilesToggle() {
            foreach (var projectType in ProjectTypes) {
                var def = new ProjectDefinition(
                    "ShowAllFiles",
                    projectType,
                    Folder("SubFolder"),
                    Compile("SubFolder\\server"),
                    Property("ProjectView", "ProjectFiles")
                );

                using (var solution = def.Generate().ToVs()) {
                    var projectNode = solution.WaitForItem("ShowAllFiles", "SubFolder", "server" + projectType.CodeExtension);
                    AutomationWrapper.Select(projectNode);

                    solution.ExecuteCommand("Project.ShowAllFiles"); // start showing all

                    Assert.IsTrue(solution.GetProject("ShowAllFiles").GetIsFolderExpanded("SubFolder"));
                }
            }
        }

        public void BasicProjectTest() {
            var sln = new ProjectDefinition(
                "HelloWorld",
                PythonProject,
                Compile("server", "")
            ).Generate();

            using (var vs = sln.ToMockVs()) {
                Assert.IsNotNull(vs.WaitForItem("HelloWorld", "Python Environments"));
                Assert.IsNotNull(vs.WaitForItem("HelloWorld", "References"));
                Assert.IsNotNull(vs.WaitForItem("HelloWorld", "Search Paths"));
                Assert.IsNotNull(vs.WaitForItem("HelloWorld", "server.py"));
                var view = vs.OpenItem("HelloWorld", "server.py");

                view.Invoke(() => view.Type("import "));

                using (var sh = view.WaitForSession<ICompletionSession>()) {
                    AssertUtil.Contains(sh.Session.Completions(), "sys");
                }
            }
        }

        public void RenameStartupFile() {
            foreach (var projectType in ProjectTypes) {
                var testDef = new ProjectDefinition(
                    "RenameStartupFileFolder",
                    projectType,
                    Folder("Folder"),
                    Compile("Folder\\server"),
                    Property("StartupFile", "Folder\\server" + projectType.CodeExtension)
                );

                using (var solution = testDef.Generate().ToVs()) {
                    var file = solution.GetProject("RenameStartupFileFolder").ProjectItems.Item("Folder").ProjectItems.Item("server" + projectType.CodeExtension);
                    file.Name = "server2" + projectType.CodeExtension;

                    Assert.AreEqual(
                        "server2" + projectType.CodeExtension,
                        Path.GetFileName(
                            (string)solution.GetProject("RenameStartupFileFolder").Properties.Item("StartupFile").Value
                        )
                    );
                }
            }
        }

        public void RenameStartupFileFolder() {
            foreach (var projectType in ProjectTypes) {
                var testDef = new ProjectDefinition(
                    "RenameStartupFileFolder", 
                    projectType,
                    Folder("Folder"),
                    Compile("Folder\\server"),
                    Property("StartupFile", "Folder\\server" + projectType.CodeExtension)
                );

                using (var solution = testDef.Generate().ToVs()) {
                    var folder = solution.GetProject("RenameStartupFileFolder").ProjectItems.Item("Folder");
                    folder.Name = "FolderNew";

                    string startupFile = (string)solution.GetProject("RenameStartupFileFolder").Properties.Item("StartupFile").Value;
                    Assert.IsTrue(
                        startupFile.EndsWith(projectType.Code("FolderNew\\server")),
                        "Expected FolderNew in path, got {0}",
                        startupFile
                    );
                }
            }
        }

        public void ShowAllFilesRapidChanges2() {
            foreach (var projectType in ProjectTypes) {
                var def = new ProjectDefinition(
                    "ShowAllFilesRapidChanges",
                    projectType,
                    Property("ProjectView", "ShowAllFiles")
                );

                using (var solution = def.Generate().ToVs()) {
                    var projectNode = solution.WaitForItem("ShowAllFilesRapidChanges");
                    AutomationWrapper.Select(projectNode);

                    HashSet<string> addedItems = new HashSet<string>();
                    for (int i = 0; i < 100; i++) {
                        var filename = Path.Combine(solution.SolutionDirectory, "ShowAllFilesRapidChanges", Path.GetRandomFileName());
                        File.WriteAllText(filename, "");
                        File.Delete(filename);
                        File.WriteAllText(filename, "");
                        addedItems.Add(filename);
                    }

                    // give some time for changes to be processed...
                    System.Threading.Thread.Sleep(10000);

                    foreach (var item in addedItems) {
                        Assert.IsNotNull(solution.WaitForItem("ShowAllFilesRapidChanges", Path.GetFileName(item)), item);
                    }
                }
            }
        }

        public void ShowAllFilesRapidChanges() {
            foreach (var projectType in ProjectTypes) {
                var def = new ProjectDefinition(
                    "ShowAllFilesRapidChanges",
                    projectType,
                    Property("ProjectView", "ShowAllFiles")
                );

                using (var solution = def.Generate().ToVs()) {
                    var projectNode = solution.WaitForItem("ShowAllFilesRapidChanges");
                    AutomationWrapper.Select(projectNode);

                    List<string> addedItems = new List<string>();
                    for (int i = 0; i < 1000; i++) {
                        var filename = Path.Combine(solution.SolutionDirectory, "ShowAllFilesRapidChanges", Path.GetRandomFileName());
                        File.WriteAllText(filename, "");
                        File.Delete(filename);
                        addedItems.Add(filename);
                    }

                    foreach (var item in addedItems) {
                        Assert.IsNull(solution.WaitForItemRemoved("ShowAllFilesRapidChanges", Path.GetFileName(item)));
                    }
                }
            }
        }

        public void ShowAllExcludeSelected() {
            foreach (var projectType in ProjectTypes) {
                var def = new ProjectDefinition(
                    "ShowAllExcludeSelected",
                    projectType,
                    ItemGroup(
                        Folder("Folder"),
                        Compile("Folder\\File1"),
                        Compile("Folder\\File2")
                    ),
                    Property("ProjectView", "ProjectFiles")
                );

                using (var solution = def.Generate().ToVs()) {
                    solution.WaitForItem("ShowAllExcludeSelected");

                    var file = solution.WaitForItem("ShowAllExcludeSelected", "Folder", "File2" + projectType.CodeExtension);
                    AutomationWrapper.Select(file);
                    solution.ExecuteCommand("Project.ExcludeFromProject");

                    solution.WaitForItemRemoved("ShowAllExcludeSelected", "Folder", "File2" + projectType.CodeExtension);

                    Assert.AreEqual("File1" + projectType.CodeExtension, Path.GetFileName(GetSelectedItemName()));

                    file = solution.WaitForItem("ShowAllExcludeSelected", "Folder", "File1" + projectType.CodeExtension);
                    AutomationWrapper.Select(file);
                    solution.ExecuteCommand("Project.ExcludeFromProject");
                    solution.WaitForItemRemoved("ShowAllExcludeSelected", "Folder", "File1" + projectType.CodeExtension);

                    Assert.AreEqual("Folder", Path.GetFileName(GetSelectedItemName().TrimEnd('\\')));
                }
            }
        }

        public void CopyDeletePaste() {
            foreach (var projectType in ProjectTypes) {
                var testDef = new ProjectDefinition("DragDropCopyCutPaste",
                    projectType,
                    ItemGroup(
                        Folder("CopyDeletePaste"),
                        Compile("CopyDeletePaste\\CopyDeletePaste")
                    )
                );

                using (var solution = testDef.Generate().ToVs()) {
                    var file = solution.WaitForItem("DragDropCopyCutPaste", "CopyDeletePaste", "CopyDeletePaste" + projectType.CodeExtension);
                    var project = solution.WaitForItem("DragDropCopyCutPaste");

                    AutomationWrapper.Select(file);
                    solution.ControlC();

                    AutomationWrapper.Select(file);
                    solution.Type(Key.Delete);
                    solution.WaitForDialog();

                    solution.Type("\r");

                    solution.WaitForDialogDismissed();

                    solution.WaitForItemRemoved("DragDropCopyCutPaste", "CopyDeletePaste", "CopyDeletePaste" + projectType.CodeExtension);

                    AutomationWrapper.Select(project);
                    solution.ControlV();

                    solution.CheckMessageBox("The source URL 'CopyDeletePaste" + projectType.CodeExtension + "' could not be found.");
                }
            }
        }

        public void ShowAllMoveNotInProject() {
            foreach (var projectType in ProjectTypes) {
                var def = new ProjectDefinition(
                    "ShowAllMoveNotInProject",
                    projectType,
                    ItemGroup(
                        Folder("Folder", isExcluded: true),
                        Folder("Folder\\SubFolder", isExcluded: true),
                        Compile("NotInProject", isExcluded:true),
                        Compile("Folder\\File", isExcluded: true),
                        Content("Folder\\SubFolder\\SubFile.txt", "", isExcluded: true)
                    ),
                    Property("ProjectView", "ShowAllFiles")
                );

                using (var solution = def.Generate().ToVs()) {
                    solution.WaitForItem("ShowAllMoveNotInProject");

                    var file = solution.WaitForItem("ShowAllMoveNotInProject", "NotInProject" + projectType.CodeExtension);
                    AutomationWrapper.Select(file);
                    Keyboard.ControlX();
                    System.Threading.Thread.Sleep(1000);

                    var folder = solution.WaitForItem("ShowAllMoveNotInProject", "Folder");
                    AutomationWrapper.Select(folder);
                    Keyboard.ControlV();

                    Assert.IsNotNull(solution.WaitForItem("ShowAllMoveNotInProject", "Folder", "NotInProject" + projectType.CodeExtension));

                    solution.ExecuteCommand("Project.ShowAllFiles"); // stop showing all

                    Assert.IsNull(solution.WaitForItemRemoved("ShowAllMoveNotInProject", "Folder", "NotInProject" + projectType.CodeExtension));

                    solution.ExecuteCommand("Project.ShowAllFiles"); // start showing again

                    var subFolder = solution.WaitForItem("ShowAllMoveNotInProject", "Folder", "SubFolder");
                    AutomationWrapper.Select(subFolder);

                    Keyboard.ControlX();
                    System.Threading.Thread.Sleep(1000);
                    var projectNode = solution.WaitForItem("ShowAllMoveNotInProject");
                    AutomationWrapper.Select(projectNode);
                    Keyboard.ControlV();
                    Assert.IsNotNull(solution.WaitForItem("ShowAllMoveNotInProject", "SubFolder"));

                    solution.ExecuteCommand("Project.ShowAllFiles"); // stop showing all

                    Assert.IsNull(solution.WaitForItemRemoved("ShowAllMoveNotInProject", "SubFolder"));
                }
            }
        }