public async Task SaveProjectWithImportedWildcardsBuildActionChangedBackAgain() { var fn = new CustomItemNode <SupportImportedProjectFilesDotNetProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { string projFile = Util.GetSampleProject("console-project-with-wildcards", "ConsoleProject-import.csproj"); string originalProjectFileText = File.ReadAllText(projFile); var p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); Assert.IsInstanceOf <Project> (p); var mp = (Project)p; mp.UseAdvancedGlobSupport = true; var f = mp.Files.FirstOrDefault(pf => pf.FilePath.FileName == "text1-1.txt"); var originalBuildAction = f.BuildAction; f.BuildAction = BuildAction.EmbeddedResource; await p.SaveAsync(Util.GetMonitor()); f.BuildAction = originalBuildAction; await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ToSystemEndings(originalProjectFileText), File.ReadAllText(p.FileName)); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task FilesImportedAreMarkedAsImported() { var fn = new CustomItemNode <SupportImportedProjectFilesProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { FilePath projFile = Util.GetSampleProject("msbuild-glob-tests", "glob-import-test2.csproj"); var textFilePath = projFile.ParentDirectory.Combine("test.txt"); File.WriteAllText(textFilePath, "test"); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; Assert.AreEqual(4, p.Files.Count); var c2File = p.Files.First(fi => fi.FilePath.FileName == "c2.cs"); var textFile = p.Files.First(fi => fi.FilePath.FileName == "test.txt"); Assert.IsFalse(textFile.IsImported); Assert.IsTrue(c2File.IsImported); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task RemoveAllFilesFromProject_NoFilesDeleted_RemoveItemAddedForFiles() { var fn = new CustomItemNode <SupportImportedProjectFilesProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { string projFile = Util.GetSampleProject("msbuild-glob-tests", "glob-import-test.csproj"); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; Assert.AreEqual(3, p.Files.Count); p.Files.Clear(); await p.SaveAsync(Util.GetMonitor()); string projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(File.ReadAllText(p.FileName.ChangeName("glob-remove-saved3")), projectXml); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task CSharpFileBuildActionChangedToNoneBackToCompileBackToNoneAgain() { var fn = new CustomItemNode <SupportImportedProjectFilesDotNetProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { string projFile = Util.GetSampleProject("console-project-with-wildcards", "ConsoleProject-imported-none-wildcard.csproj"); var p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); Assert.IsInstanceOf <Project> (p); var mp = (Project)p; mp.UseAdvancedGlobSupport = true; var f = mp.Files.FirstOrDefault(pf => pf.FilePath.FileName == "Program.cs"); f.BuildAction = BuildAction.None; await p.SaveAsync(Util.GetMonitor()); f = mp.Files.FirstOrDefault(pf => pf.FilePath.FileName == "Program.cs"); f.BuildAction = BuildAction.Compile; await p.SaveAsync(Util.GetMonitor()); f = mp.Files.FirstOrDefault(pf => pf.FilePath.FileName == "Program.cs"); f.BuildAction = BuildAction.None; await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ReadAllWithWindowsEndings(p.FileName + ".saved1"), Util.ReadAllWithWindowsEndings(p.FileName)); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task SaveProjectWithImportedWildcardsBuildActionChangedThenCopyToOutputChanged() { var fn = new CustomItemNode <SupportImportedProjectFilesDotNetProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { string projFile = Util.GetSampleProject("console-project-with-wildcards", "ConsoleProject-import.csproj"); var p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); Assert.IsInstanceOf <Project> (p); var mp = (Project)p; mp.UseAdvancedGlobSupport = true; var f = mp.Files.FirstOrDefault(pf => pf.FilePath.FileName == "text1-1.txt"); f.BuildAction = BuildAction.EmbeddedResource; await p.SaveAsync(Util.GetMonitor()); f.CopyToOutputDirectory = FileCopyMode.PreserveNewest; await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ReadAllWithWindowsEndings(p.FileName + ".saved1"), Util.ReadAllWithWindowsEndings(p.FileName)); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public void TagsInItemExtension() { var p = new TestTagProvider(); StringParserService.RegisterStringTagProvider(p); var node = new CustomItemNode <StringTagTestExtension> (); WorkspaceObject.RegisterCustomExtension(node); try { var project = Services.ProjectService.CreateDotNetProject("C#"); var modeld = project.GetStringTagModelDescription(ConfigurationSelector.Default); Assert.IsTrue(modeld.GetTags().Any(t => t.Name == "foo")); var model = project.GetStringTagModel(ConfigurationSelector.Default); Assert.AreEqual("bar", model.GetValue("foo")); project.Dispose(); } finally { StringParserService.UnregisterStringTagProvider(p); WorkspaceObject.UnregisterCustomExtension(node); } }
public async Task FlavorLoadSaveExtendedPropertiesWithUnknownProperty() { // Unknown data should be kept in the file string projFile = Util.GetSampleProject("extended-project-properties", "test-unknown-data.myproj"); string projectXml1 = File.ReadAllText(projFile); var tn = new MyEmptyProjectTypeNode(); var fn = new CustomItemNode <FlavorWithData> (); MSBuildProjectService.RegisterCustomItemType(tn); WorkspaceObject.RegisterCustomExtension(fn); try { var p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); Assert.IsInstanceOf <MyEmptyProject> (p); var mp = (MyEmptyProject)p; var f = mp.GetFlavor <FlavorWithData> (); Assert.NotNull(f.Data); Assert.AreEqual(f.Data.Foo, "bar"); Assert.AreEqual(f.SimpleData, "Test"); await mp.SaveAsync(Util.GetMonitor()); string projectXml2 = File.ReadAllText(projFile); Assert.AreEqual(projectXml1, projectXml2); p.Dispose(); } finally { MSBuildProjectService.UnregisterCustomItemType(tn); WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task DependentUponUsingFileNameMetadataProperty() { var fn = new CustomItemNode <SupportImportedProjectFilesProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { FilePath projFile = Util.GetSampleProject("msbuild-glob-tests", "glob-import-metadata-prop.csproj"); string expectedProjectXml = File.ReadAllText(projFile); var xamlCSharpFileName = projFile.ParentDirectory.Combine("test.xaml.cs"); File.WriteAllText(xamlCSharpFileName, "csharp"); var xamlFileName = projFile.ParentDirectory.Combine("test.xaml"); File.WriteAllText(xamlFileName, "xaml"); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; var xamlCSharpFile = p.Files.Single(fi => fi.FilePath.FileName == "test.xaml.cs"); var xamlFile = p.Files.Single(fi => fi.FilePath.FileName == "test.xaml"); Assert.AreEqual(xamlFileName.ToString(), xamlCSharpFile.DependsOn); Assert.AreEqual(xamlCSharpFile.DependsOnFile, xamlFile); // Ensure the expanded %(FileName) does not get added to the main project on saving. await p.SaveAsync(Util.GetMonitor()); string projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(expectedProjectXml, projectXml); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task WriteCustomData() { var en = new CustomSolutionItemNode <TestSolutionExtension> (); WorkspaceObject.RegisterCustomExtension(en); try { string solFile = Util.GetSampleProject("solution-custom-data", "custom-data.sln"); var sol = new Solution(); var ext = sol.GetService <TestSolutionExtension> (); Assert.NotNull(ext); ext.Prop1 = "one"; ext.Prop2 = "two"; ext.Extra = new ComplexSolutionData { Prop3 = "three", Prop4 = "four" }; var savedFile = solFile + ".saved.sln"; await sol.SaveAsync(savedFile, Util.GetMonitor()); Assert.AreEqual(File.ReadAllText(solFile), File.ReadAllText(savedFile)); sol.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(en); } }
public async Task FlavorLoadExtendedProperties_InitialEmptyGroup() { // Check that data load works when it is not defined in the main group // Test for BXC 41774. string projFile = Util.GetSampleProject("extended-project-properties", "test-data-empty-group.myproj"); var tn = new MyEmptyProjectTypeNode(); var fn = new CustomItemNode <FlavorWithData> (); MSBuildProjectService.RegisterCustomItemType(tn); WorkspaceObject.RegisterCustomExtension(fn); try { var p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); Assert.IsInstanceOf <MyEmptyProject> (p); var mp = (MyEmptyProject)p; var f = mp.GetFlavor <FlavorWithData> (); Assert.NotNull(f.Data); Assert.AreEqual(f.Data.Foo, "bar"); Assert.AreEqual(f.SimpleData, "Test"); p.Dispose(); } finally { MSBuildProjectService.UnregisterCustomItemType(tn); WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task RemoveCustomData() { var en = new CustomSolutionItemNode <TestSolutionExtension> (); WorkspaceObject.RegisterCustomExtension(en); try { FilePath solFile = Util.GetSampleProject("solution-custom-data", "custom-data.sln"); var sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var ext = sol.GetService <TestSolutionExtension> (); ext.Prop1 = "xx"; ext.Prop2 = ""; ext.Extra = null; var refFile = solFile.ParentDirectory.Combine("no-custom-data.sln"); await sol.SaveAsync(Util.GetMonitor()); Assert.AreEqual(File.ReadAllText(refFile), File.ReadAllText(sol.FileName)); sol.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(en); } }
public async Task OnConfigureTargetEvaluationContext() { var node = new CustomItemNode <EvalContextCreationTestExtension> (); WorkspaceObject.RegisterCustomExtension(node); EvalContextCreationTestExtension.ControlValue = "First"; try { string solFile = Util.GetSampleProject("fast-build-test", "FastBuildTest.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var app = (DotNetProject)sol.Items [0]; var cs = new SolutionConfigurationSelector("Debug"); Assert.IsTrue(app.FastCheckNeedsBuild(cs)); var res = await sol.Build(Util.GetMonitor(), cs); Assert.IsFalse(res.HasErrors); Assert.IsFalse(app.FastCheckNeedsBuild(cs)); EvalContextCreationTestExtension.ControlValue = "Changed"; Assert.IsTrue(app.FastCheckNeedsBuild(cs)); res = await sol.Build(Util.GetMonitor(), cs); Assert.IsFalse(res.HasErrors); Assert.IsFalse(app.FastCheckNeedsBuild(cs)); sol.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(node); } }
public async Task FileUpdateChangeThenRemoveMetadata2() { var fn = new CustomItemNode <SupportImportedProjectFilesProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { string projFile = Util.GetSampleProject("msbuild-glob-tests", "glob-import-test.csproj"); string originalProjFile = new FilePath(projFile).ChangeName("glob-import-test-original.csproj"); File.Copy(projFile, originalProjFile); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; Assert.AreEqual(3, p.Files.Count); var f = p.Files.First(fi => fi.FilePath.FileName == "c2.cs"); f.Metadata.SetValue("foo", "bar"); await p.SaveAsync(Util.GetMonitor()); string projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(File.ReadAllText(p.FileName.ChangeName("glob-import-update1-test")), projectXml); f.Metadata.RemoveProperty("foo"); await p.SaveAsync(Util.GetMonitor()); projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(File.ReadAllText(originalProjFile), projectXml); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task RemoveFileLink() { var fn = new CustomItemNode <SupportImportedProjectFilesProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { FilePath projFile = Util.GetSampleProject("msbuild-glob-tests", "glob-file-link-test.csproj"); string linkedFile = Path.Combine(projFile.ParentDirectory, "..", "test.txt"); File.WriteAllText(linkedFile, "test"); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; Assert.AreEqual(4, p.Files.Count); var f = p.Files.First(fi => fi.FilePath.FileName == "test.txt"); Assert.IsTrue(f.IsLink); p.Files.Remove(f); await p.SaveAsync(Util.GetMonitor()); string expectedProjectXml = File.ReadAllText(p.FileName.ChangeName("glob-file-link-test-saved1")); string projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(expectedProjectXml, projectXml); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task ProjectExtensionOnModifiedCalledWhenProjectModified() { var fn = new CustomItemNode <TestModifiedProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; TestModifiedProjectExtension.ModifiedEventArgs.Clear(); p.NotifyModified("Files"); var args = TestModifiedProjectExtension.ModifiedEventArgs.Single(); var eventInfo = args.Single(); Assert.AreEqual("Files", eventInfo.Hint); Assert.AreEqual(p, eventInfo.SolutionItem); Assert.AreEqual(sol, eventInfo.Solution); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public void Teardown() { WorkspaceObject.UnregisterCustomExtension(capaNode); // Unregister test addin. File.Delete(testAddinAssemblyPath); AddinManager.Registry.Update(null); }
public void Teardown() { WorkspaceObject.UnregisterCustomExtension(capaNode); // Ensure MonoDevelop.Core.Tests addin is not registered in local-config after tests are run. string localConfigFile = Path.Combine(Util.TestsRootDir, "..", "..", "local-config", "MonoDevelop.Core.Tests.Addin.addins"); File.Delete(localConfigFile); }
public async Task Reevaluate_AfterReferenceRemovedFromProject_BeforeProjectSaved2() { FilePath oldProjectFile = Util.GetSampleProject("console-project", "ConsoleProject", "ConsoleProject.csproj.reference-added"); FilePath projectFile = oldProjectFile.ParentDirectory.Combine("ConsoleProject-reference-added.csproj"); File.Move(oldProjectFile, projectFile); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projectFile); var systemXmlLinqRef = p.References.Single(r => r.Include == "System.Xml.Linq"); var systemNetRef = p.References.Single(r => r.Include == "System.Net"); Assert.AreEqual(5, p.References.Count); var fn = new CustomItemNode <RemoveReferenceOnReevaluateProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { int itemAdded = 0; int itemRemoved = 0; int configAdded = 0; int configRemoved = 0; bool configsChanged = false; bool runConfigsChanged = false; bool capabilitiesChanged = false; p.ProjectItemAdded += (sender, e) => itemAdded += e.Count; p.ProjectItemRemoved += (sender, e) => itemRemoved += e.Count; p.ConfigurationAdded += (sender, e) => configAdded++; p.ConfigurationRemoved += (sender, e) => configRemoved++; p.ConfigurationsChanged += (sender, e) => configsChanged = true; p.RunConfigurationsChanged += (sender, e) => runConfigsChanged = true; p.ProjectCapabilitiesChanged += (sender, e) => capabilitiesChanged = true; await p.ReevaluateProject(Util.GetMonitor()); Assert.IsFalse(p.References.Any(r => r.Include == "System.Xml.Linq")); Assert.IsFalse(p.References.Any(r => r.Include == "System.Net")); Assert.AreEqual(3, p.References.Count); await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(Util.ToSystemEndings(File.ReadAllText(p.FileName)), File.ReadAllText(p.FileName.ParentDirectory.Combine("ConsoleProject.csproj"))); Assert.AreEqual(0, itemAdded); Assert.AreEqual(2, itemRemoved); Assert.AreEqual(0, configAdded); Assert.AreEqual(0, configRemoved); Assert.IsFalse(configsChanged); Assert.IsFalse(runConfigsChanged); Assert.IsFalse(capabilitiesChanged); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task Reevaluate_AfterReferenceAddedToProject_BeforeProjectSaved2() { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; Assert.AreEqual(3, p.References.Count); var fn = new CustomItemNode <AddReferenceOnReevaluateProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { int itemAdded = 0; int itemRemoved = 0; int configAdded = 0; int configRemoved = 0; bool configsChanged = false; bool runConfigsChanged = false; bool capabilitiesChanged = false; p.ProjectItemAdded += (sender, e) => itemAdded += e.Count; p.ProjectItemRemoved += (sender, e) => itemRemoved += e.Count; p.ConfigurationAdded += (sender, e) => configAdded++; p.ConfigurationRemoved += (sender, e) => configRemoved++; p.ConfigurationsChanged += (sender, e) => configsChanged = true; p.RunConfigurationsChanged += (sender, e) => runConfigsChanged = true; p.ProjectCapabilitiesChanged += (sender, e) => capabilitiesChanged = true; await p.ReevaluateProject(Util.GetMonitor()); Assert.AreEqual(1, p.References.Count(r => r.Include == "System.Xml.Linq")); Assert.AreEqual(1, p.References.Count(r => r.Include == "System.Net")); Assert.AreEqual(5, p.References.Count); await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(File.ReadAllText(p.FileName), Util.ToSystemEndings(File.ReadAllText(p.FileName + ".reference-added"))); Assert.AreEqual(2, itemAdded); Assert.AreEqual(0, itemRemoved); Assert.AreEqual(0, configAdded); Assert.AreEqual(0, configRemoved); Assert.IsFalse(configsChanged); Assert.IsFalse(runConfigsChanged); Assert.IsFalse(capabilitiesChanged); sol.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task Remove_WildCardHasMetadataProperties() { var fn = new CustomItemNode <SupportImportedProjectFilesProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { FilePath projFile = Util.GetSampleProject("msbuild-glob-tests", "glob-import-metadata-prop.csproj"); string expectedProjectXml = File.ReadAllText(projFile); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; var xamlFileName1 = projFile.ParentDirectory.Combine("MyView1.xaml"); File.WriteAllText(xamlFileName1, "xaml1"); var xamlCSharpFileName = projFile.ParentDirectory.Combine("MyView1.xaml.cs"); File.WriteAllText(xamlCSharpFileName, "csharpxaml"); var xamlFile1 = new ProjectFile(xamlFileName1, BuildAction.EmbeddedResource); xamlFile1.Generator = "MSBuild:UpdateDesignTimeXaml"; xamlFile1.ContentType = "Designer"; p.Files.Add(xamlFile1); var xamlCSharpFile = p.AddFile(xamlCSharpFileName); xamlCSharpFile.DependsOn = "MyView1.xaml"; // Ensure no items are added to the project on saving. await p.SaveAsync(Util.GetMonitor()); string projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(expectedProjectXml, projectXml); // Remove .xaml.cs file but do not delete it. p.Files.Remove(xamlCSharpFile); await p.SaveAsync(Util.GetMonitor()); // Remove item should be added for .xaml.cs file. projectXml = File.ReadAllText(p.FileName); expectedProjectXml = File.ReadAllText(p.FileName.ChangeName("glob-import-metadata-prop-saved1")); Assert.AreEqual(expectedProjectXml, projectXml); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task SolutionStartupItemChangedAfterReevaluation() { var node = new TestCapabilityNode(); WorkspaceObject.RegisterCustomExtension(node); try { string solFile = Util.GetSampleProject("project-capability-tests", "Library", "Library.sln"); var solution = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var item = solution.GetAllProjects().Single(); string projectExtension = "TestCapabilityExtension"; Func <ProjectExtension, bool> isMatch = f => f.GetType().Name == projectExtension; var ext = item.GetFlavors().FirstOrDefault(isMatch); Assert.IsNull(ext); // Library project is the only project in the solution so the startup item // should be null. Assert.IsNull(solution.StartupItem); // Now activate "TestCapability" capability which enables the project to // support execution. var import = item.MSBuildProject.AddNewImport("testcapability.targets"); await item.ReevaluateProject(Util.GetMonitor()); ext = item.GetFlavors().FirstOrDefault(isMatch); Assert.IsNotNull(ext); // Startup item is not set for the solution. Assert.AreEqual(item, solution.StartupItem); item.MSBuildProject.RemoveImport(import); await item.ReevaluateProject(Util.GetMonitor()); ext = item.GetFlavors().FirstOrDefault(isMatch); Assert.IsNull(ext); // Startup item is now set to null since no project can be executed. Assert.IsNull(solution.StartupItem); item.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(node); } }
public async Task AddFile_WildCardHasMetadataProperties() { var fn = new CustomItemNode <SupportImportedProjectFilesProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { FilePath projFile = Util.GetSampleProject("msbuild-glob-tests", "glob-import-metadata-prop.csproj"); string expectedProjectXml = File.ReadAllText(projFile); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; var xamlFileName1 = projFile.ParentDirectory.Combine("MyView1.xaml"); File.WriteAllText(xamlFileName1, "xaml1"); var xamlCSharpFileName = projFile.ParentDirectory.Combine("MyView1.xaml.cs"); File.WriteAllText(xamlCSharpFileName, "csharpxaml"); // Xaml file with Generator and Subtype set to match that defined in the glob. var xamlFile1 = new ProjectFile(xamlFileName1, BuildAction.EmbeddedResource); xamlFile1.Generator = "MSBuild:UpdateDesignTimeXaml"; xamlFile1.ContentType = "Designer"; p.Files.Add(xamlFile1); var xamlCSharpFile = p.AddFile(xamlCSharpFileName); xamlCSharpFile.DependsOn = "MyView1.xaml"; // Ensure no items are added to the project on saving. await p.SaveAsync(Util.GetMonitor()); string projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(expectedProjectXml, projectXml); // Save again. A second save was adding an include for the .xaml file whilst // the first save was not. await p.SaveAsync(Util.GetMonitor()); projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(expectedProjectXml, projectXml); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task RemoveAllFilesFromProject_ProjectHasOneFileWithUpdateItem_RemoveItemAddedAndUpdateItemRemoved() { var fn = new CustomItemNode <SupportImportedProjectFilesProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { string projFile = Util.GetSampleProject("msbuild-glob-tests", "glob-remove-test2.csproj"); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; Assert.AreEqual(3, p.Files.Count); var f2 = p.Files.First(fi => fi.FilePath.FileName == "c2.cs"); var f3 = p.Files.First(fi => fi.FilePath.FileName == "c3.cs"); File.Delete(f2.FilePath); File.Delete(f3.FilePath); p.Files.Remove(f2); p.Files.Remove(f3); await p.SaveAsync(Util.GetMonitor()); // Single c1.cs Update item in project. No other .cs files found by the file glob. // With two or more files the bug does not happen. Also need to reload the project // otherwise the bug does not happen. p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; Assert.AreEqual(1, p.Files.Count); // Remove c1.cs file but do not delete it. p.Files.Clear(); await p.SaveAsync(Util.GetMonitor()); string projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(File.ReadAllText(p.FileName.ChangeName("glob-remove-saved2")), projectXml); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task SolutionDisposed_ActiveProjectTasks_MSBuildEngineManagerNotDisposedUntilProjectTasksCompleted() { var en = new CustomSolutionItemNode <TestProjectExtension> (); WorkspaceObject.RegisterCustomExtension(en); try { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); var sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; var msbuildProject = p.MSBuildProject; var ext = p.GetFlavor <TestProjectExtension> (); var task = ext.RunTestTask(); sol.Dispose(); // Should not throw. Evaluating requires the MSBuildEngineManager to not be disposed. msbuildProject.Evaluate(); try { // Ensure that BindTask cannot be used after Solution has been disposed but // project has not yet been disposed. await p.BindTask(ct => Task.CompletedTask); Assert.Fail("Should not reach here."); } catch (TaskCanceledException) { // Expected } try { // Ensure that BindTask<T> cannot be used after Solution has been disposed but // project has not yet been disposed. await p.BindTask(ct => Task.FromResult(true)); Assert.Fail("Should not reach here."); } catch (TaskCanceledException) { // Expected } ext.TaskCompletionSource.TrySetResult(true); await task; } finally { WorkspaceObject.UnregisterCustomExtension(en); } }
public async Task ReadCustomData() { var en = new CustomSolutionItemNode <TestSolutionExtension> (); WorkspaceObject.RegisterCustomExtension(en); try { string solFile = Util.GetSampleProject("solution-custom-data", "custom-data.sln"); var sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var ext = sol.GetService <TestSolutionExtension> (); Assert.NotNull(ext); Assert.AreEqual("one", ext.Prop1); Assert.AreEqual("two", ext.Prop2); Assert.NotNull(ext.Extra); Assert.AreEqual("three", ext.Extra.Prop3); Assert.AreEqual("four", ext.Extra.Prop4); } finally { WorkspaceObject.UnregisterCustomExtension(en); } }
public async Task SerializedWrite() { var node = new CustomItemNode <SerializedSaveTestExtension> (); WorkspaceObject.RegisterCustomExtension(node); try { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; var op1 = p.SaveAsync(Util.GetMonitor()); var op2 = p.SaveAsync(Util.GetMonitor()); await op1; await op2; Assert.AreEqual(2, SerializedSaveTestExtension.SaveCount); } finally { WorkspaceObject.UnregisterCustomExtension(node); } }
public async Task DeleteAllFilesFromProject_ProjectHasOneFileWithUpdateItem_UpdateItemRemoved() { var fn = new CustomItemNode <SupportImportedProjectFilesProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { FilePath projFile = Util.GetSampleProject("msbuild-glob-tests", "glob-import-test.csproj"); string expectedProjectXml = File.ReadAllText(projFile); // Leave only the c1.cs file. var c2File = projFile.ParentDirectory.Combine("c2.cs"); var c3File = projFile.ParentDirectory.Combine("c3.cs"); File.Delete(c2File); File.Delete(c3File); var p = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); p.UseAdvancedGlobSupport = true; Assert.AreEqual(1, p.Files.Count); var c1File = p.Files.First(fi => fi.FilePath.FileName == "c1.cs"); c1File.CopyToOutputDirectory = FileCopyMode.Always; await p.SaveAsync(Util.GetMonitor()); File.Delete(c1File.FilePath); p.Files.Clear(); await p.SaveAsync(Util.GetMonitor()); string projectXml = File.ReadAllText(p.FileName); Assert.AreEqual(expectedProjectXml, projectXml); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task DeleteFileAndThenAddNewFileToProjectWithSingleFileAndImportedCSharpFilesWildcard() { var fn = new CustomItemNode <SupportImportedProjectFilesDotNetProjectExtension> (); WorkspaceObject.RegisterCustomExtension(fn); try { string projFile = Util.GetSampleProject("console-project-imported-wildcard", "ConsoleProject-imported-wildcard.csproj"); string originalProjectFileText = File.ReadAllText(projFile); var p = await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), projFile); Assert.IsInstanceOf <Project> (p); var mp = (Project)p; mp.UseAdvancedGlobSupport = true; var f = mp.Files.Single(); Assert.AreEqual("Program.cs", f.FilePath.FileName); string fileToDelete = f.FilePath; File.Delete(fileToDelete); mp.Files.Remove(f); await mp.SaveAsync(Util.GetMonitor()); string newFile = Path.Combine(p.BaseDirectory, "Test.cs"); File.WriteAllText(newFile, "class Test { }"); mp.AddFile(newFile); await mp.SaveAsync(Util.GetMonitor()); // Second save was triggering a null reference. await mp.SaveAsync(Util.GetMonitor()); var savedProjFileText = File.ReadAllText(projFile); Assert.AreEqual(originalProjectFileText, savedProjFileText); p.Dispose(); } finally { WorkspaceObject.UnregisterCustomExtension(fn); } }
public async Task KeepUnknownCustomData() { var en = new CustomSolutionItemNode <TestSolutionExtension> (); WorkspaceObject.RegisterCustomExtension(en); try { FilePath solFile = Util.GetSampleProject("solution-custom-data", "custom-data-keep-unknown.sln"); var sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var ext = sol.GetService <TestSolutionExtension> (); ext.Prop1 = "one-mod"; ext.Prop2 = ""; ext.Extra.Prop3 = "three-mod"; ext.Extra.Prop4 = ""; var refFile = solFile.ParentDirectory.Combine("custom-data-keep-unknown.sln.saved"); await sol.SaveAsync(Util.GetMonitor()); Assert.AreEqual(File.ReadAllText(refFile), File.ReadAllText(sol.FileName)); } finally { WorkspaceObject.UnregisterCustomExtension(en); } }
public void Teardown() { WorkspaceObject.UnregisterCustomExtension(capaNode); }