public void LoadReferenceWithSpaces_bug43510()
{
var pref = ProjectReference.CreateAssemblyReference(" gtk-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f");
var p = (DotNetProject)Services.ProjectService.CreateProject("C#");
p.References.Add(pref);
Assert.IsTrue(pref.IsValid);
}
public async Task Reevaluate_AfterReferenceAddedToProject_BeforeProjectSaved()
{
string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln");
Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p = (DotNetProject)sol.Items [0];
Assert.AreEqual(3, p.References.Count);
var systemXmlLinqRef = ProjectReference.CreateAssemblyReference("System.Xml.Linq");
p.References.Add(systemXmlLinqRef);
var systemNetRef = ProjectReference.CreateAssemblyReference("System.Net");
p.References.Add(systemNetRef);
int itemAdded = 0;
int itemRemoved = 0;
int configAdded = 0;
int configRemoved = 0;
bool configsChanged = false;
bool runConfigsChanged = false;
bool capabilitiesChanged = false;
p.ProjectItemAdded += (sender, e) => itemAdded += e.Count;
p.ProjectItemRemoved += (sender, e) => itemRemoved += e.Count;
p.ConfigurationAdded += (sender, e) => configAdded++;
p.ConfigurationRemoved += (sender, e) => configRemoved++;
p.ConfigurationsChanged += (sender, e) => configsChanged = true;
p.RunConfigurationsChanged += (sender, e) => runConfigsChanged = true;
p.ProjectCapabilitiesChanged += (sender, e) => capabilitiesChanged = true;
await p.ReevaluateProject(Util.GetMonitor());
Assert.AreEqual(0, itemAdded);
Assert.AreEqual(0, itemRemoved);
Assert.AreEqual(0, configAdded);
Assert.AreEqual(0, configRemoved);
Assert.IsFalse(configsChanged);
Assert.IsFalse(runConfigsChanged);
Assert.IsFalse(capabilitiesChanged);
Assert.AreEqual(systemXmlLinqRef, p.References.Single(r => r.Include == "System.Xml.Linq"));
Assert.AreEqual(systemNetRef, p.References.Single(r => r.Include == "System.Net"));
Assert.AreEqual(5, p.References.Count);
await p.SaveAsync(Util.GetMonitor());
Assert.AreEqual(File.ReadAllText(p.FileName), Util.ToSystemEndings(File.ReadAllText(p.FileName + ".reference-added")));
sol.Dispose();
}
public async Task RefreshInMemoryProjectFirstTime()
{
// 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 refs = (await p.GetReferencedAssemblies(ConfigurationSelector.Default)).ToArray();
Assert.IsTrue(refs.Any(r => r.FilePath.FileName == "System.Xml.Linq.dll"));
}
protected internal override Task OnReevaluateProject(ProgressMonitor monitor)
{
var builder = ImmutableList.CreateBuilder <ProjectItem> ();
var systemXmlLinq = ProjectReference.CreateAssemblyReference("System.Xml.Linq");
var systemNet = ProjectReference.CreateAssemblyReference("System.Net");
builder.Add(systemXmlLinq);
builder.Add(systemNet);
Project.References.Add(systemXmlLinq);
Project.References.Add(systemNet);
Project.itemsAddedDuringReevaluation = builder;
return(base.OnReevaluateProject(monitor));
}
public async Task ReferenceWithVersion()
{
string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln");
var sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile);
var p = (DotNetProject)sol.Items [0];
var reference = ProjectReference.CreateAssemblyReference("System.Core, Version=4.0.0.0");
p.References.Add(reference);
Assert.AreEqual(string.Empty, reference.ValidationErrorMessage);
p.References.Remove(reference);
reference = ProjectReference.CreateAssemblyReference("System.Core, Version=55.44.22.11"); //non-existing version
p.References.Add(reference);
Assert.AreNotEqual(string.Empty, reference.ValidationErrorMessage); //Not equal...
}
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);
}
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 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 static Solution CreateConsoleSolution(string hint)
{
string dir = Util.CreateTmpDir(hint);
Solution sol = new Solution();
SolutionConfiguration scDebug = sol.AddConfiguration("Debug", true);
DotNetProject project = Services.ProjectService.CreateDotNetProject("C#");
sol.RootFolder.Items.Add(project);
Assert.AreEqual(0, project.Configurations.Count);
InitializeProject(dir, project, "TestProject");
project.References.Add(ProjectReference.CreateAssemblyReference("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
project.References.Add(ProjectReference.CreateAssemblyReference("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
project.References.Add(ProjectReference.CreateAssemblyReference("System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"));
project.Files.Add(new ProjectFile(Path.Combine(dir, "Program.cs")));
project.Files.Add(new ProjectFile(Path.Combine(dir, "Resource.xml"), BuildAction.EmbeddedResource));
project.Files.Add(new ProjectFile(Path.Combine(dir, "Excluded.xml"), BuildAction.Content));
ProjectFile pf = new ProjectFile(Path.Combine(dir, "Copy.xml"), BuildAction.Content);
pf.CopyToOutputDirectory = FileCopyMode.Always;
project.Files.Add(pf);
project.Files.Add(new ProjectFile(Path.Combine(dir, "Nothing.xml"), BuildAction.None));
Assert.IsFalse(scDebug.GetEntryForItem(project).Build);
scDebug.GetEntryForItem(project).Build = true;
SolutionConfiguration scRelease = sol.AddConfiguration("Release", true);
string file = Path.Combine(dir, "TestSolution.sln");
sol.FileName = file;
Assert.AreEqual(2, sol.Configurations.Count);
Assert.AreEqual(1, scDebug.Configurations.Count);
Assert.AreEqual(1, scRelease.Configurations.Count);
Assert.AreEqual(2, project.Configurations.Count);
foreach (var v in project.Files)
{
if (v.FilePath.FileName == "Program.cs")
{
File.WriteAllText(v.FilePath,
@"
using System;
namespace Foo {
public class MainClass {
public static void Main (string [] args)
{
}
}
}");
}
else
{
File.WriteAllText(v.FilePath, v.Name);
}
}
return(sol);
}
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);
}
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]);
}
