async Task <Document> CreateDocument(string input) { var text = input; int endPos = text.IndexOf('$'); if (endPos >= 0) { text = text.Substring(0, endPos) + text.Substring(endPos + 1); } if (solution != null) { TypeSystemService.Unload(solution); solution.Dispose(); } var project = Services.ProjectService.CreateDotNetProject("C#"); project.Name = "test"; project.References.Add(MonoDevelop.Projects.ProjectReference.CreateAssemblyReference("mscorlib")); project.References.Add(MonoDevelop.Projects.ProjectReference.CreateAssemblyReference("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")); project.References.Add(MonoDevelop.Projects.ProjectReference.CreateAssemblyReference("System.Core")); project.FileName = "test.csproj"; project.Files.Add(new ProjectFile("/a.cs", BuildAction.Compile)); solution = new MonoDevelop.Projects.Solution(); solution.AddConfiguration("", true); solution.DefaultSolutionFolder.AddItem(project); using (var monitor = new ProgressMonitor()) await TypeSystemService.Load(solution, monitor); var tww = new TestWorkbenchWindow(); var content = new TestViewContent(); tww.ViewContent = content; content.ContentName = "/a.cs"; content.Data.MimeType = "text/x-csharp"; content.Project = project; content.Text = text; content.CursorPosition = Math.Max(0, endPos); var doc = new Document(tww); doc.SetProject(project); var compExt = new CSharpCompletionTextEditorExtension(); compExt.Initialize(doc.Editor, doc); content.Contents.Add(compExt); await doc.UpdateParseDocument(); return(doc); }
public override void TearDown() { solution?.Dispose(); solution = null; base.TearDown(); }
public async Task SolutionFolderTags() { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var model = sol.RootFolder.GetStringTagModel(ConfigurationSelector.Default); Assert.AreEqual(sol.FileName, model.GetValue("SolutionFile")); Assert.AreEqual("ConsoleProject", model.GetValue("SolutionName")); Assert.AreEqual(sol.ItemDirectory, model.GetValue("SolutionDir")); var mdesc = sol.GetStringTagModelDescription(ConfigurationSelector.Default); var tt = mdesc.GetTags().Select(t => t.Name).ToArray(); Assert.That(tt.Contains("SolutionFile")); Assert.That(tt.Contains("SolutionName")); Assert.That(tt.Contains("SolutionDir")); sol.Dispose(); }
public async Task NoEvents() { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution item = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var myLogger = new MSBuildLogger(); TargetEvaluationContext ctx = new TargetEvaluationContext(); ctx.Loggers.Add(myLogger); myLogger.EnabledEvents = MSBuildEvent.None; int events = 0; myLogger.EventRaised += (sender, e) => events++; await item.Build(Util.GetMonitor(), "Debug", ctx); Assert.AreEqual(0, events); item.Dispose(); }
public async Task UserProperties() { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; sol.UserProperties.SetValue("SolProp", "foo"); p.UserProperties.SetValue("ProjectProp", "bar"); await sol.SaveUserProperties(); sol.Dispose(); sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); p = (DotNetProject)sol.Items [0]; Assert.AreEqual("foo", sol.UserProperties.GetValue <string> ("SolProp")); Assert.AreEqual("bar", p.UserProperties.GetValue <string> ("ProjectProp")); }
public async Task FastBuildCheckWithLibrary() { 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 lib = (DotNetProject)sol.Items [1]; var cs = new SolutionConfigurationSelector("Debug"); Assert.IsTrue(app.FastCheckNeedsBuild(cs)); Assert.IsTrue(lib.FastCheckNeedsBuild(cs)); var res = await sol.Build(Util.GetMonitor(), cs); Assert.IsFalse(res.HasErrors); Assert.IsFalse(app.FastCheckNeedsBuild(cs)); Assert.IsFalse(lib.FastCheckNeedsBuild(cs)); var myClass = sol.ItemDirectory.Combine("MyClass.cs"); File.WriteAllText(myClass, "public class MyClass { public const string Message = \"Bye\" ; }"); FileService.NotifyFileChanged(myClass); Assert.IsTrue(app.FastCheckNeedsBuild(cs)); Assert.IsTrue(lib.FastCheckNeedsBuild(cs)); res = await lib.Build(Util.GetMonitor(), cs); Assert.IsFalse(res.HasErrors); Assert.IsFalse(lib.FastCheckNeedsBuild(cs)); Assert.IsTrue(app.FastCheckNeedsBuild(cs)); res = await app.Build(Util.GetMonitor(), cs); Assert.IsFalse(res.HasErrors); Assert.IsFalse(lib.FastCheckNeedsBuild(cs)); Assert.IsFalse(app.FastCheckNeedsBuild(cs)); sol.Dispose(); }
public async Task BuildConfigurationMappings() { string solFile = Util.GetSampleProject("test-build-configs", "test-build-configs.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); DotNetProject lib1 = (DotNetProject)sol.FindProjectByName("Lib1"); DotNetProject lib2 = (DotNetProject)sol.FindProjectByName("Lib2"); DotNetProject lib3 = (DotNetProject)sol.FindProjectByName("Lib3"); DotNetProject lib4 = (DotNetProject)sol.FindProjectByName("Lib4"); // Check that the output file names are correct Assert.AreEqual(GetConfigFolderName(lib1, "Debug"), "Debug"); Assert.AreEqual(GetConfigFolderName(lib1, "Release"), "Release"); Assert.AreEqual(GetConfigFolderName(lib2, "Debug"), "Release"); Assert.AreEqual(GetConfigFolderName(lib2, "Release"), "Debug"); Assert.AreEqual(GetConfigFolderName(lib3, "Debug"), "DebugExtra"); Assert.AreEqual(GetConfigFolderName(lib3, "Release"), "ReleaseExtra"); // Check that building the solution builds the correct project configurations await CheckSolutionBuildClean(sol, "Debug"); await CheckSolutionBuildClean(sol, "Release"); // Check that building a project builds the correct referenced project configurations await CheckProjectReferencesBuildClean(sol, "Debug"); await CheckProjectReferencesBuildClean(sol, "Release"); // Single project build and clean await CheckProjectBuildClean(lib2, "Debug"); await CheckProjectBuildClean(lib2, "Release"); await CheckProjectBuildClean(lib3, "Debug"); await CheckProjectBuildClean(lib3, "Release"); await CheckProjectBuildClean(lib4, "Debug"); await CheckProjectBuildClean(lib4, "Release"); sol.Dispose(); }
public async Task ExtraConfigurationInNewProject() { string dir = Util.CreateTmpDir("ConfigurationsInNewProject"); var sol = new Solution(); sol.FileName = Path.Combine(dir, "TestSolution.sln"); sol.AddConfiguration("Debug", true); var p = Services.ProjectService.CreateDotNetProject("C#"); p.ItemId = "{3A83F683-760F-486C-8844-B0F079B30B25}"; p.FileName = Path.Combine(dir, "TestProject.csproj"); sol.RootFolder.Items.Add(p); Assert.AreEqual(1, p.RunConfigurations.Count); var es = p.RunConfigurations [0]; Assert.AreEqual("Default", es.Name); var conf = (AssemblyRunConfiguration)p.CreateRunConfiguration("Extra"); conf.ExternalConsole = true; p.RunConfigurations.Add(conf); await sol.SaveAsync(Util.GetMonitor()); string projectXml = File.ReadAllText(p.FileName); string projFile = Util.GetSampleProject("run-configurations", "ConsoleProject", "ConsoleProject.new-project-extra.csproj"); string newProjectXml = File.ReadAllText(projFile); Assert.AreEqual(Util.ToWindowsEndings(newProjectXml), projectXml); Assert.IsTrue(File.Exists(p.FileName + ".user")); projectXml = File.ReadAllText(p.FileName + ".user"); newProjectXml = File.ReadAllText(projFile + ".user"); Assert.AreEqual(newProjectXml, projectXml); sol.Dispose(); }
public async Task SaveFileInProjectExternallyAfterSolutionNotWatched_NoFileChangeEventsFired() { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; var file = p.Files.First(f => f.FilePath.FileName == "Program.cs"); ClearFileEventsCaptured(); await FileWatcherService.Add(sol); sol.Dispose(); sol = null; TextFileUtility.WriteText(file.FilePath, string.Empty, Encoding.UTF8); await WaitForFileChanged(file.FilePath); Assert.AreEqual(0, fileChanges.Count); }
public void SharedProjectCantBeStartup() { var sol = new Solution(); var shared = new SharedAssetsProject(); // Shared projects are not executable Assert.IsFalse(shared.SupportsExecute()); sol.RootFolder.AddItem(shared); // The shared project is not executable, so it shouldn't be set as startup by default Assert.IsNull(sol.StartupItem); // An executable project is set as startup by default when there is no startup project var project = Services.ProjectService.CreateDotNetProject("C#"); sol.RootFolder.AddItem(project); Assert.IsTrue(sol.StartupItem == project); sol.Dispose(); }
public async Task ProjectReferencingConditionalReferences() { string solFile = Util.GetSampleProject("conditional-project-reference", "conditional-project-reference.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = sol.Items.FirstOrDefault(pr => pr.Name == "conditional-project-reference"); Assert.AreEqual(2, p.GetReferencedItems((SolutionConfigurationSelector)"DebugWin").Count()); Assert.AreEqual(1, p.GetReferencedItems((SolutionConfigurationSelector)"Debug").Count()); //We have intentional compile error in windowsLib project var res = await p.Build(Util.GetMonitor(), (SolutionConfigurationSelector)"DebugWin", true); Assert.AreEqual(1, res.ErrorCount); res = await p.Build(Util.GetMonitor(), (SolutionConfigurationSelector)"Debug", true); Assert.AreEqual(0, res.ErrorCount); sol.Dispose(); }
public async Task RefreshInMemoryProject() { // Check that the builder is refreshed when the file has been modified in memory. string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; // This will force the loading of the builder (await p.GetReferencedAssemblies(ConfigurationSelector.Default)).ToArray(); p.References.Add(ProjectReference.CreateAssemblyReference("System.Xml.Linq")); var refs = (await p.GetReferencedAssemblies(ConfigurationSelector.Default)).ToArray(); // Check that the in-memory project data is used when the builder is loaded for the first time. Assert.IsTrue(refs.Any(r => r.FilePath.FileName == "System.Xml.Linq.dll")); sol.Dispose(); }
public async Task EvaluateUnknownPropertyDuringBuild() { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var project = ((Project)sol.Items[0]); var context = new TargetEvaluationContext(); context.PropertiesToEvaluate.Add("TestUnknownPropertyToEvaluate"); var res = await project.RunTarget(Util.GetMonitor(), "Build", project.Configurations[0].Selector, context); Assert.IsNotNull(res); Assert.IsNotNull(res.BuildResult); Assert.AreEqual(0, res.BuildResult.ErrorCount); Assert.AreEqual(0, res.BuildResult.WarningCount); Assert.IsNull(res.Properties.GetValue("TestUnknownPropertyToEvaluate")); sol.Dispose(); }
public void SolutionName() { int nameChanges = 0; Solution sol = new Solution(); sol.NameChanged += delegate { nameChanges++; }; string tmp = Path.GetTempPath(); sol.Name = "test1"; Assert.AreEqual("test1", sol.Name); Assert.AreEqual("test1.sln", (string)sol.FileName); Assert.AreEqual(1, nameChanges); sol.Name = "test2"; Assert.AreEqual("test2", sol.Name); Assert.AreEqual("test2.sln", (string)sol.FileName); Assert.AreEqual(2, nameChanges); sol.FileName = Path.Combine(tmp, "test3.sln"); Assert.AreEqual("test3", sol.Name); Assert.AreEqual(Path.Combine(tmp, "test3.sln"), (string)sol.FileName); Assert.AreEqual(3, nameChanges); sol.Name = "test4"; Assert.AreEqual("test4", sol.Name); Assert.AreEqual(Path.Combine(tmp, "test4.sln"), (string)sol.FileName); Assert.AreEqual(4, nameChanges); sol.ConvertToFormat(MSBuildFileFormat.VS2010); Assert.AreEqual("test4", sol.Name); Assert.AreEqual(Path.Combine(tmp, "test4.sln"), (string)sol.FileName); Assert.AreEqual(4, nameChanges); sol.Dispose(); }
public async Task AddingRemovingAndThenAddingReferenceToPortableLibrarySavesReferenceToFile() { string solFile = Util.GetSampleProject("portable-library", "portable-library.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = sol.FindProjectByName("PortableLibrary") as DotNetProject; Assert.AreEqual(0, p.References.Count); // Add System.Xml reference. p.References.Add(ProjectReference.CreateAssemblyReference("System.Xml")); await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(1, p.References.Count); // Remove System.Xml reference so no references remain. p.References.RemoveAt(0); await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(0, p.References.Count); // Add System.Xml reference again. p.References.Add(ProjectReference.CreateAssemblyReference("System.Xml")); await p.SaveAsync(Util.GetMonitor()); Assert.AreEqual(1, p.References.Count); // Ensure the references are saved to the file. sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); p = sol.FindProjectByName("PortableLibrary") as DotNetProject; Assert.AreEqual(1, p.References.Count); Assert.AreEqual("System.Xml", p.References [0].Include); sol.Dispose(); }
public static async Task TestCreateLoadSaveConsoleProject(MSBuildFileFormat fileFormat) { Solution sol = CreateConsoleSolution("TestCreateLoadSaveConsoleProject"); sol.ConvertToFormat(fileFormat); await sol.SaveAsync(Util.GetMonitor()); string solFile = sol.FileName; sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); CheckConsoleProject(sol); // Save over existing file await sol.SaveAsync(Util.GetMonitor()); sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); CheckConsoleProject(sol); sol.Dispose(); }
public async Task SolutionTags() { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; sol.LocalAuthorInformation = new AuthorInformation("test name", "test email", "test copy", "test company", "test trademark"); var model = sol.GetStringTagModel(ConfigurationSelector.Default); Assert.AreEqual(sol.FileName, model.GetValue("SolutionFile")); Assert.AreEqual("ConsoleProject", model.GetValue("SolutionName")); Assert.AreEqual(sol.ItemDirectory, model.GetValue("SolutionDir")); var mdesc = sol.GetStringTagModelDescription(ConfigurationSelector.Default); var tt = mdesc.GetTags().Select(t => t.Name).ToArray(); Assert.That(tt.Contains("SolutionFile")); Assert.That(tt.Contains("SolutionName")); Assert.That(tt.Contains("SolutionDir")); sol.Dispose(); }
public async Task AddReference() { // Check that the in-memory project data is used when the builder is loaded for the first time. string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; p.References.Add(ProjectReference.CreateAssemblyReference("System.Xml.Linq")); var asm = p.AssemblyContext.GetAssemblies().FirstOrDefault(a => a.Name == "System.Net"); p.References.Add(ProjectReference.CreateAssemblyReference(asm)); await p.SaveAsync(Util.GetMonitor()); var refXml = Util.ToSystemEndings(File.ReadAllText(p.FileName + ".reference-added")); var savedXml = File.ReadAllText(p.FileName); Assert.AreEqual(refXml, savedXml); sol.Dispose(); }
public async Task MDResourceNamingPolicy() { 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 pol = new DotNetNamingPolicy(DirectoryNamespaceAssociation.Flat, ResourceNamePolicy.FileName); p.Policies.Set(pol); var f = p.AddFile(p.BaseDirectory.Combine("foo/SomeFile.txt"), BuildAction.EmbeddedResource); Assert.AreEqual("SomeFile.txt", f.ResourceId); await p.SaveAsync(Util.GetMonitor()); var p2 = (DotNetProject)await Services.ProjectService.ReadSolutionItem(Util.GetMonitor(), p.FileName); f = p2.GetProjectFile(f.FilePath); Assert.AreEqual("SomeFile.txt", f.ResourceId); sol.Dispose(); }
public void SolutionItemsEvents() { int countFileAddedToProject = 0; int countFileRemovedFromProject = 0; int countFileRenamedInProject = 0; int countReferenceAddedToProject = 0; int countReferenceRemovedFromProject = 0; int countSolutionItemAdded = 0; int countSolutionItemRemoved = 0; Solution sol = new Solution(); sol.FileAddedToProject += delegate { countFileAddedToProject++; }; sol.FileRemovedFromProject += delegate { countFileRemovedFromProject++; }; sol.FileRenamedInProject += delegate { countFileRenamedInProject++; }; sol.ReferenceAddedToProject += delegate { countReferenceAddedToProject++; }; sol.ReferenceRemovedFromProject += delegate { countReferenceRemovedFromProject++; }; sol.SolutionItemAdded += delegate { countSolutionItemAdded++; }; sol.SolutionItemRemoved += delegate { countSolutionItemRemoved++; }; Assert.AreEqual(0, countFileAddedToProject); Assert.AreEqual(0, countFileRemovedFromProject); Assert.AreEqual(0, countFileRenamedInProject); Assert.AreEqual(0, countReferenceAddedToProject); Assert.AreEqual(0, countReferenceRemovedFromProject); Assert.AreEqual(0, countSolutionItemAdded); Assert.AreEqual(0, countSolutionItemRemoved); SolutionFolder folder = new SolutionFolder(); folder.Name = "Folder1"; sol.RootFolder.Items.Add(folder); Assert.AreEqual(1, countSolutionItemAdded); Assert.AreEqual(0, sol.Items.Count); var project = Services.ProjectService.CreateDotNetProject("C#"); project.Name = "project1"; sol.RootFolder.Items.Add(project); Assert.AreEqual(2, countSolutionItemAdded); Assert.AreEqual(1, sol.Items.Count); var project2 = Services.ProjectService.CreateDotNetProject("C#"); project2.Name = "project2"; folder.Items.Add(project2); Assert.AreEqual(3, countSolutionItemAdded); Assert.AreEqual(2, sol.Items.Count); ProjectFile p1 = new ProjectFile("test1.cs"); project2.Files.Add(p1); Assert.AreEqual(1, countFileAddedToProject); ProjectFile p2 = new ProjectFile("test1.cs"); project.Files.Add(p2); Assert.AreEqual(2, countFileAddedToProject); p1.Name = "test2.cs"; Assert.AreEqual(1, countFileRenamedInProject); p2.Name = "test2.cs"; Assert.AreEqual(2, countFileRenamedInProject); project2.Files.Remove(p1); Assert.AreEqual(1, countFileRemovedFromProject); project.Files.Remove("test2.cs"); Assert.AreEqual(2, countFileRemovedFromProject); ProjectReference pr1 = ProjectReference.CreateAssemblyReference("SomeTest"); project.References.Add(pr1); Assert.AreEqual(1, countReferenceAddedToProject); ProjectReference pr2 = ProjectReference.CreateProjectReference(project); project2.References.Add(pr2); Assert.AreEqual(2, countReferenceAddedToProject); project.References.Remove(pr1); Assert.AreEqual(1, countReferenceRemovedFromProject); sol.RootFolder.Items.Remove(project); Assert.AreEqual(2, countReferenceRemovedFromProject, "Removing a project must remove all references to it"); Assert.AreEqual(1, countSolutionItemRemoved); Assert.AreEqual(1, sol.Items.Count); folder.Items.Remove(project2); Assert.AreEqual(2, countSolutionItemRemoved); Assert.AreEqual(0, sol.Items.Count); sol.RootFolder.Items.Remove(folder); Assert.AreEqual(2, countFileAddedToProject); Assert.AreEqual(2, countFileRemovedFromProject); Assert.AreEqual(2, countFileRenamedInProject); Assert.AreEqual(2, countReferenceAddedToProject); Assert.AreEqual(2, countReferenceRemovedFromProject); Assert.AreEqual(3, countSolutionItemAdded); Assert.AreEqual(3, countSolutionItemRemoved); sol.Dispose(); }
public async Task BuildingAndCleaning() { string solFile = Util.GetSampleProject("console-with-libs", "console-with-libs.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); DotNetProject p = (DotNetProject)sol.FindProjectByName("console-with-libs"); DotNetProject lib1 = (DotNetProject)sol.FindProjectByName("library1"); DotNetProject lib2 = (DotNetProject)sol.FindProjectByName("library2"); SolutionFolder folder = new SolutionFolder(); folder.Name = "subfolder"; sol.RootFolder.Items.Add(folder); sol.RootFolder.Items.Remove(lib2); folder.Items.Add(lib2); Workspace ws = new Workspace(); ws.FileName = Path.Combine(sol.BaseDirectory, "workspace"); ws.Items.Add(sol); await ws.SaveAsync(Util.GetMonitor()); // Build the project and the references BuildResult res = await ws.Build(Util.GetMonitor(), ConfigurationSelector.Default); Assert.AreEqual(0, res.ErrorCount); Assert.AreEqual(0, res.WarningCount); Assert.AreEqual(3, res.BuildCount); Assert.IsTrue(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe"))); Assert.IsTrue(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe")))); Assert.IsTrue(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll"))); Assert.IsTrue(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll")))); Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll"))); Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll")))); // Clean the workspace await ws.Clean(Util.GetMonitor(), ConfigurationSelector.Default); Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe"))); Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe")))); Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll"))); Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll")))); Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll"))); Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll")))); // Build the solution res = await ws.Build(Util.GetMonitor(), ConfigurationSelector.Default); Assert.AreEqual(0, res.ErrorCount); Assert.AreEqual(0, res.WarningCount); Assert.AreEqual(3, res.BuildCount); Assert.IsTrue(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe"))); Assert.IsTrue(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe")))); Assert.IsTrue(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll"))); Assert.IsTrue(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll")))); Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll"))); Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll")))); // Clean the solution await sol.Clean(Util.GetMonitor(), "Debug"); Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe"))); Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe")))); Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll"))); Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll")))); Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll"))); Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll")))); // Build the solution folder res = await folder.Build(Util.GetMonitor(), (SolutionConfigurationSelector)"Debug"); Assert.AreEqual(0, res.ErrorCount); Assert.AreEqual(0, res.WarningCount); Assert.AreEqual(1, res.BuildCount); Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", "console-with-libs.exe"))); Assert.IsFalse(File.Exists(Util.Combine(p.BaseDirectory, "bin", "Debug", GetMdb(p, "console-with-libs.exe")))); Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", "library1.dll"))); Assert.IsFalse(File.Exists(Util.Combine(lib1.BaseDirectory, "bin", "Debug", GetMdb(lib1, "library1.dll")))); Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll"))); Assert.IsTrue(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll")))); // Clean the solution folder await folder.Clean(Util.GetMonitor(), (SolutionConfigurationSelector)"Debug"); Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", "library2.dll"))); Assert.IsFalse(File.Exists(Util.Combine(lib2.BaseDirectory, "bin", "Debug", GetMdb(lib2, "library2.dll")))); sol.Dispose(); }
public async Task SaveSharedProject() { Solution sol = TestProjectsChecks.CreateConsoleSolution("shared-project"); sol.ConvertToFormat(MSBuildFileFormat.VS2012); await sol.SaveAsync(Util.GetMonitor()); var pc = (DotNetProject)sol.Items [0]; // Add shared project var sp = new SharedAssetsProject() { LanguageName = "C#", DefaultNamespace = "TestNamespace" }; sp.AddFile(sol.ItemDirectory.Combine("Test.cs")); await sp.SaveAsync(Util.GetMonitor(), sol.ItemDirectory.Combine("Shared")); sol.RootFolder.AddItem(sp); await sol.SaveAsync(Util.GetMonitor()); // Make sure we compare using the same guid string solXml = File.ReadAllText(sol.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}").Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); string projectXml = Util.GetXmlFileInfoset(pc.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}"); string sharedProjectXml = Util.GetXmlFileInfoset(sp.FileName).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); string sharedProjectItemsXml = Util.GetXmlFileInfoset(sp.FileName.ChangeExtension(".projitems")).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); string refSolXml = Util.ToWindowsEndings(File.ReadAllText(Util.GetSampleProjectPath("generated-shared-project", "TestSolution.sln"))); string refProjectXml = Util.ToWindowsEndings(Util.GetXmlFileInfoset(Util.GetSampleProjectPath("generated-shared-project", "TestProject.csproj"))); string refSharedProjectXml = Util.ToWindowsEndings(Util.GetXmlFileInfoset(Util.GetSampleProjectPath("generated-shared-project", "Shared.shproj"))); string refSharedProjectItemsXml = Util.ToWindowsEndings(Util.GetXmlFileInfoset(Util.GetSampleProjectPath("generated-shared-project", "Shared.projitems"))); Assert.AreEqual(refSolXml, solXml); Assert.AreEqual(refProjectXml, projectXml); Assert.AreEqual(refSharedProjectXml, sharedProjectXml); Assert.AreEqual(refSharedProjectItemsXml, sharedProjectItemsXml); // Add a reference var r = ProjectReference.CreateProjectReference(sp); pc.References.Add(r); await sol.SaveAsync(Util.GetMonitor()); solXml = File.ReadAllText(sol.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}").Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); projectXml = Util.GetXmlFileInfoset(pc.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}"); sharedProjectXml = Util.GetXmlFileInfoset(sp.FileName).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); sharedProjectItemsXml = Util.GetXmlFileInfoset(sp.FileName.ChangeExtension(".projitems")).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); refProjectXml = Util.ToWindowsEndings(Util.GetXmlFileInfoset(Util.GetSampleProjectPath("generated-shared-project", "TestProject.csproj.saved1"))); Assert.AreEqual(refSolXml, solXml); Assert.AreEqual(refProjectXml, projectXml); Assert.AreEqual(refSharedProjectXml, sharedProjectXml); Assert.AreEqual(refSharedProjectItemsXml, sharedProjectItemsXml); // Add a file and change the default namespace sp.DefaultNamespace = "TestNamespace2"; var file = sp.AddFile(sol.ItemDirectory.Combine("Test2.cs")); await sol.SaveAsync(Util.GetMonitor()); solXml = File.ReadAllText(sol.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}").Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); projectXml = Util.GetXmlFileInfoset(pc.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}"); sharedProjectXml = Util.GetXmlFileInfoset(sp.FileName).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); sharedProjectItemsXml = Util.GetXmlFileInfoset(sp.FileName.ChangeExtension(".projitems")).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); refSharedProjectItemsXml = Util.ToWindowsEndings(Util.GetXmlFileInfoset(Util.GetSampleProjectPath("generated-shared-project", "Shared.projitems.saved1"))); Assert.AreEqual(refSolXml, solXml); Assert.AreEqual(refProjectXml, projectXml); Assert.AreEqual(refSharedProjectXml, sharedProjectXml); Assert.AreEqual(refSharedProjectItemsXml, sharedProjectItemsXml); // Remove a file and restore the namespace sp.DefaultNamespace = "TestNamespace"; sp.Files.Remove(file); await sol.SaveAsync(Util.GetMonitor()); solXml = File.ReadAllText(sol.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}").Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); projectXml = Util.GetXmlFileInfoset(pc.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}"); sharedProjectXml = Util.GetXmlFileInfoset(sp.FileName).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); sharedProjectItemsXml = Util.GetXmlFileInfoset(sp.FileName.ChangeExtension(".projitems")).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); refSharedProjectItemsXml = Util.ToWindowsEndings(Util.GetXmlFileInfoset(Util.GetSampleProjectPath("generated-shared-project", "Shared.projitems"))); Assert.AreEqual(refSolXml, solXml); Assert.AreEqual(refProjectXml, projectXml); Assert.AreEqual(refSharedProjectXml, sharedProjectXml); Assert.AreEqual(refSharedProjectItemsXml, sharedProjectItemsXml); // Remove reference pc.References.Remove(r); await sol.SaveAsync(Util.GetMonitor()); solXml = File.ReadAllText(sol.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}").Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); projectXml = Util.GetXmlFileInfoset(pc.FileName).Replace(pc.ItemId, "{7DE4B613-BAB6-49DE-83FA-707D4E120306}"); sharedProjectXml = Util.GetXmlFileInfoset(sp.FileName).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); sharedProjectItemsXml = Util.GetXmlFileInfoset(sp.FileName.ChangeExtension(".projitems")).Replace(sp.ItemId, "{8DD793BE-42C3-4D66-8359-460CEE75980D}"); refProjectXml = Util.ToWindowsEndings(Util.GetXmlFileInfoset(Util.GetSampleProjectPath("generated-shared-project", "TestProject.csproj"))); Assert.AreEqual(refSolXml, solXml); Assert.AreEqual(refProjectXml, projectXml); Assert.AreEqual(refSharedProjectXml, sharedProjectXml); Assert.AreEqual(refSharedProjectItemsXml, sharedProjectItemsXml); sol.Dispose(); }
public async Task AddRemoveReferenceEvents() { string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); var p = (DotNetProject)sol.Items [0]; int added = 0, removed = 0, modifiedRefs = 0, modifiedItems = 0, refsChanged = 0; // We should get two ReferenceAdded events (one for each reference), but only one global modified and assemblies changed event. var refs = new [] { ProjectReference.CreateAssemblyReference("Foo"), ProjectReference.CreateAssemblyReference("Bar") }; p.ReferenceAddedToProject += delegate { added++; Assert.IsTrue(refs.All(r => r.OwnerProject != null)); }; p.ReferenceRemovedFromProject += delegate { removed++; Assert.IsTrue(refs.All(r => r.OwnerProject == null)); }; EventHandler refsChangedHandler = delegate { refsChanged++; Assert.IsTrue(refs.All(r => r.OwnerProject != null)); }; p.ReferencedAssembliesChanged += refsChangedHandler; SolutionItemModifiedEventHandler modifiedHandler = delegate(object sender, SolutionItemModifiedEventArgs e) { foreach (var ev in e) { if (ev.Hint == "References") { modifiedRefs++; } if (ev.Hint == "Items") { modifiedItems++; } } Assert.IsTrue(refs.All(r => r.OwnerProject != null)); }; p.Modified += modifiedHandler; p.References.AddRange(refs); Assert.AreEqual(2, added); Assert.AreEqual(1, modifiedRefs); Assert.AreEqual(1, modifiedItems); Assert.AreEqual(1, refsChanged); modifiedRefs = modifiedItems = refsChanged = 0; p.ReferencedAssembliesChanged -= refsChangedHandler; p.Modified -= modifiedHandler; refsChangedHandler = delegate { refsChanged++; Assert.IsTrue(refs.All(r => r.OwnerProject == null)); }; p.ReferencedAssembliesChanged += refsChangedHandler; modifiedHandler = delegate(object sender, SolutionItemModifiedEventArgs e) { foreach (var ev in e) { if (ev.Hint == "References") { modifiedRefs++; } if (ev.Hint == "Items") { modifiedItems++; } } Assert.IsTrue(refs.All(r => r.OwnerProject == null)); }; p.Modified += modifiedHandler; p.References.RemoveRange(refs); Assert.AreEqual(2, removed); Assert.AreEqual(1, modifiedRefs); Assert.AreEqual(1, modifiedItems); Assert.AreEqual(1, refsChanged); sol.Dispose(); }
public async Task RefreshReferences() { string solFile = Util.GetSampleProject("reference-refresh", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); DotNetProject project = sol.GetAllItems <DotNetProject> ().FirstOrDefault(); Assert.AreEqual(4, project.References.Count); ProjectReference r; r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference == "test"); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly); Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("test.dll").FullPath.ToString()); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference == "gtk-sharp"); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly); Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("gtk-sharp.dll").FullPath.ToString()); Assert.IsTrue(r.IsValid); // Refresh without any change project.RefreshReferenceStatus(); Assert.AreEqual(4, project.References.Count); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference == "test"); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly); Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("test.dll").FullPath.ToString()); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference == "gtk-sharp"); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly); Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("gtk-sharp.dll").FullPath.ToString()); Assert.IsTrue(r.IsValid); // Refresh after deleting test.dll File.Move(project.BaseDirectory.Combine("test.dll"), project.BaseDirectory.Combine("test.dll.tmp")); project.RefreshReferenceStatus(); Assert.AreEqual(4, project.References.Count); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference == "test"); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsFalse(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference == "gtk-sharp"); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly); Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("gtk-sharp.dll").FullPath.ToString()); Assert.IsTrue(r.IsValid); // Refresh after deleting gtk-sharp.dll File.Move(project.BaseDirectory.Combine("gtk-sharp.dll"), project.BaseDirectory.Combine("gtk-sharp.dll.tmp")); project.RefreshReferenceStatus(); Assert.AreEqual(4, project.References.Count); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference == "test"); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsFalse(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("gtk-sharp,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.AreEqual("gtk-sharp.dll", Path.GetFileName(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single())); Assert.IsTrue(r.IsValid); // Refresh after restoring gtk-sharp.dll and test.dll File.Move(project.BaseDirectory.Combine("test.dll.tmp"), project.BaseDirectory.Combine("test.dll")); File.Move(project.BaseDirectory.Combine("gtk-sharp.dll.tmp"), project.BaseDirectory.Combine("gtk-sharp.dll")); project.RefreshReferenceStatus(); Assert.AreEqual(4, project.References.Count); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("System.Xml,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Package); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference == "test"); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly); Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("test.dll").FullPath.ToString()); Assert.IsTrue(r.IsValid); r = project.References.FirstOrDefault(re => re.Reference.StartsWith("gtk-sharp,")); Assert.IsNotNull(r); Assert.AreEqual(r.ReferenceType, ReferenceType.Assembly); Assert.AreEqual(r.GetReferencedFileNames(project.DefaultConfiguration.Selector).Single(), project.BaseDirectory.Combine("gtk-sharp.dll").FullPath.ToString()); Assert.IsTrue(r.IsValid); sol.Dispose(); }
public async Task FileDependencies() { string solFile = Util.GetSampleProject("file-dependencies", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); Project p = (Project)sol.Items [0]; var dir = p.BaseDirectory; var file1 = p.Files.GetFile(dir.Combine("file1.xml")); var file2 = p.Files.GetFile(dir.Combine("file2.xml")); var file3 = p.Files.GetFile(dir.Combine("file3.xml")); var file4 = p.Files.GetFile(dir.Combine("file4.xml")); var file5 = p.Files.GetFile(dir.Combine("file5.xml")); Assert.AreEqual(file3, file1.DependsOnFile); Assert.AreEqual(file3, file2.DependsOnFile); Assert.AreEqual(2, file3.DependentChildren.Count); Assert.IsTrue(file3.DependentChildren.Contains(file1)); Assert.IsTrue(file3.DependentChildren.Contains(file2)); Assert.AreEqual(file5, file4.DependsOnFile); Assert.AreEqual(1, file5.DependentChildren.Count); Assert.IsTrue(file5.DependentChildren.Contains(file4)); // Change a dependency file1.DependsOn = ""; Assert.IsNull(file1.DependsOnFile); Assert.AreEqual(file3, file2.DependsOnFile); Assert.AreEqual(1, file3.DependentChildren.Count); Assert.IsTrue(file3.DependentChildren.Contains(file2)); // Unresolved dependency file1.DependsOn = "foo.xml"; Assert.IsNull(file1.DependsOnFile); var foo = p.AddFile(dir.Combine("foo.xml")); Assert.AreEqual(foo, file1.DependsOnFile); // Resolved dependency file2.DependsOn = "foo.xml"; Assert.AreEqual(foo, file2.DependsOnFile); Assert.AreEqual(0, file3.DependentChildren.Count); // Remove a file p.Files.Remove(file5); Assert.IsNull(file4.DependsOnFile); // Add a file file5 = p.AddFile(dir.Combine("file5.xml")); Assert.AreEqual(file5, file4.DependsOnFile); Assert.AreEqual(1, file5.DependentChildren.Count); Assert.IsTrue(file5.DependentChildren.Contains(file4)); sol.Dispose(); }
public static async Task TestLoadSaveSolutionFolders(MSBuildFileFormat fileFormat) { List <string> ids = new List <string> (); Solution sol = new Solution(); sol.ConvertToFormat(fileFormat); string dir = Util.CreateTmpDir("solution-folders"); sol.FileName = Path.Combine(dir, "TestSolutionFolders"); sol.Name = "TheSolution"; var p1 = Services.ProjectService.CreateDotNetProject("C#"); p1.FileName = Path.Combine(dir, "p1"); sol.RootFolder.Items.Add(p1); string idp1 = p1.ItemId; Assert.IsFalse(string.IsNullOrEmpty(idp1)); Assert.IsFalse(ids.Contains(idp1)); ids.Add(idp1); SolutionFolder f1 = new SolutionFolder(); f1.Name = "f1"; sol.RootFolder.Items.Add(f1); string idf1 = f1.ItemId; Assert.IsFalse(string.IsNullOrEmpty(idf1)); Assert.IsFalse(ids.Contains(idf1)); ids.Add(idf1); var p2 = Services.ProjectService.CreateDotNetProject("C#"); p2.FileName = Path.Combine(dir, "p2"); f1.Items.Add(p2); string idp2 = p2.ItemId; Assert.IsFalse(string.IsNullOrEmpty(idp2)); Assert.IsFalse(ids.Contains(idp2)); ids.Add(idp2); SolutionFolder f2 = new SolutionFolder(); f2.Name = "f2"; f1.Items.Add(f2); string idf2 = f2.ItemId; Assert.IsFalse(string.IsNullOrEmpty(idf2)); Assert.IsFalse(ids.Contains(idf2)); ids.Add(idf2); var p3 = Services.ProjectService.CreateDotNetProject("C#"); p3.FileName = Path.Combine(dir, "p3"); f2.Items.Add(p3); string idp3 = p3.ItemId; Assert.IsFalse(string.IsNullOrEmpty(idp3)); Assert.IsFalse(ids.Contains(idp3)); ids.Add(idp3); var p4 = Services.ProjectService.CreateDotNetProject("C#"); p4.FileName = Path.Combine(dir, "p4"); f2.Items.Add(p4); string idp4 = p4.ItemId; Assert.IsFalse(string.IsNullOrEmpty(idp4)); Assert.IsFalse(ids.Contains(idp4)); ids.Add(idp4); await sol.SaveAsync(Util.GetMonitor()); Solution sol2 = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), sol.FileName); Assert.AreEqual(4, sol2.Items.Count); Assert.AreEqual(2, sol2.RootFolder.Items.Count); Assert.AreEqual("MonoDevelop.CSharp.Project.CSharpProject", sol2.RootFolder.Items[0].GetType().FullName); Assert.AreEqual(typeof(SolutionFolder), sol2.RootFolder.Items [1].GetType()); Assert.AreEqual("p1", sol2.RootFolder.Items [0].Name); Assert.AreEqual("f1", sol2.RootFolder.Items [1].Name); Assert.AreEqual(idp1, sol2.RootFolder.Items [0].ItemId, "idp1"); Assert.AreEqual(idf1, sol2.RootFolder.Items [1].ItemId, "idf1"); f1 = (SolutionFolder)sol2.RootFolder.Items [1]; Assert.AreEqual(2, f1.Items.Count); Assert.AreEqual("MonoDevelop.CSharp.Project.CSharpProject", f1.Items [0].GetType().FullName); Assert.AreEqual(typeof(SolutionFolder), f1.Items [1].GetType()); Assert.AreEqual("p2", f1.Items [0].Name); Assert.AreEqual("f2", f1.Items [1].Name); Assert.AreEqual(idp2, f1.Items [0].ItemId, "idp2"); Assert.AreEqual(idf2, f1.Items [1].ItemId, "idf2"); f2 = (SolutionFolder)f1.Items [1]; Assert.AreEqual(2, f2.Items.Count); Assert.AreEqual("MonoDevelop.CSharp.Project.CSharpProject", f2.Items [0].GetType().FullName); Assert.AreEqual("MonoDevelop.CSharp.Project.CSharpProject", f2.Items [1].GetType().FullName); Assert.AreEqual("p3", f2.Items [0].Name); Assert.AreEqual("p4", f2.Items [1].Name); Assert.AreEqual(idp3, f2.Items [0].ItemId, "idp4"); Assert.AreEqual(idp4, f2.Items [1].ItemId, "idp4"); sol.Dispose(); }
public void SolutionBoundUnbound() { Solution sol = new Solution(); var e = new SomeItem(); Assert.AreEqual(0, e.BoundEvents); Assert.AreEqual(0, e.UnboundEvents); sol.RootFolder.AddItem(e); Assert.AreEqual(1, e.BoundEvents); Assert.AreEqual(0, e.UnboundEvents); Assert.AreEqual(1, e.InternalItem.BoundEvents); Assert.AreEqual(0, e.InternalItem.UnboundEvents); e.Reset(); sol.RootFolder.Items.Remove(e); Assert.AreEqual(0, e.BoundEvents); Assert.AreEqual(1, e.UnboundEvents); Assert.AreEqual(0, e.InternalItem.BoundEvents); Assert.AreEqual(1, e.InternalItem.UnboundEvents); e.Reset(); sol.RootFolder.AddItem(e); Assert.AreEqual(1, e.BoundEvents); Assert.AreEqual(0, e.UnboundEvents); Assert.AreEqual(1, e.InternalItem.BoundEvents); Assert.AreEqual(0, e.InternalItem.UnboundEvents); e.Reset(); sol.RootFolder.Items.Remove(e); Assert.AreEqual(0, e.BoundEvents); Assert.AreEqual(1, e.UnboundEvents); Assert.AreEqual(0, e.InternalItem.BoundEvents); Assert.AreEqual(1, e.InternalItem.UnboundEvents); e.Reset(); var f = new SolutionFolder(); f.AddItem(e); Assert.AreEqual(0, e.BoundEvents); Assert.AreEqual(0, e.UnboundEvents); Assert.AreEqual(0, e.InternalItem.BoundEvents); Assert.AreEqual(0, e.InternalItem.UnboundEvents); sol.RootFolder.AddItem(f); Assert.AreEqual(1, e.BoundEvents); Assert.AreEqual(0, e.UnboundEvents); Assert.AreEqual(1, e.InternalItem.BoundEvents); Assert.AreEqual(0, e.InternalItem.UnboundEvents); e.Reset(); sol.RootFolder.Items.Remove(f); Assert.AreEqual(0, e.BoundEvents); Assert.AreEqual(1, e.UnboundEvents); Assert.AreEqual(0, e.InternalItem.BoundEvents); Assert.AreEqual(1, e.InternalItem.UnboundEvents); f.Dispose(); sol.Dispose(); }
public async Task MakefileSynchronization() { if (Platform.IsWindows) { Assert.Ignore(); } string solFile = Util.GetSampleProject("console-project-with-makefile", "ConsoleProject.sln"); Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile); DotNetProject p = (DotNetProject)sol.Items [0]; Assert.AreEqual(2, p.Files.Count); string f = Path.Combine(p.BaseDirectory, "Program.cs"); Assert.IsTrue(p.Files.GetFile(f) != null, "Contains Program.cs"); f = Path.Combine(p.BaseDirectory, "Properties"); f = Path.Combine(f, "AssemblyInfo.cs"); Assert.IsTrue(p.Files.GetFile(f) != null, "Contains Properties/AssemblyInfo.cs"); List <string> refs = new List <string> (); refs.Add("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"); refs.Add("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"); refs.Add("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"); Assert.AreEqual(3, p.References.Count); ProjectReference xmlRef = null; foreach (ProjectReference pref in p.References) { Assert.IsTrue(refs.Contains(pref.Reference), "Contains reference " + pref.Reference); refs.Remove(pref.Reference); if (pref.Reference.StartsWith("System.Xml")) { xmlRef = pref; } } // Test saving p.References.Remove(xmlRef); p.References.Add(ProjectReference.CreateAssemblyReference("System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")); p.Files.Remove(f); p.Files.Add(new ProjectFile(Path.Combine(p.BaseDirectory, "Class1.cs"), BuildAction.Compile)); await sol.SaveAsync(Util.GetMonitor()); string makefile = File.ReadAllText(Path.Combine(p.BaseDirectory, "Makefile")); string[] values = GetVariable(makefile, "FILES").Split(' '); Assert.AreEqual(2, values.Length); Assert.AreEqual("Class1.cs", values [0]); Assert.AreEqual("Program.cs", values [1]); values = GetVariable(makefile, "REFERENCES").Split(' '); Assert.AreEqual(3, values.Length); Assert.AreEqual("System", values [0]); Assert.AreEqual("System.Data", values [1]); Assert.AreEqual("System.Web", values [2]); sol.Dispose(); }