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();
}
