public void Init()
{
resultChangedCalled = false;
classesAdded = new List<TestClass>();
classesRemoved = new List<TestClass>();
// Create a project.
project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
// Add a test class with a TestFixture attributes.
projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
MockClass c = new MockClass(projectContent, "RootNamespace.MyTestFixture");
c.SetCompoundClass(c);
c.Attributes.Add(new MockAttribute("TestFixture"));
projectContent.Classes.Add(c);
// Add a second class that has no test fixture attribute.
MockClass nonTestClass = new MockClass(projectContent);
projectContent.Classes.Add(nonTestClass);
testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport();
testProject = new TestProject(project, projectContent, testFrameworks);
testProject.TestClasses.TestClassAdded += TestClassAdded;
testProject.TestClasses.TestClassRemoved += TestClassRemoved;
testClass = testProject.TestClasses[0];
}
public static void AreEqual(ReferenceProjectItem expectedReferenceItem, ReferenceProjectItem actualReferenceItem)
{
string[] expectedValues = GetReferenceProjectItemAsStrings(expectedReferenceItem);
string[] actualValues = GetReferenceProjectItemAsStrings(actualReferenceItem);
Assert.AreEqual(expectedValues, actualValues);
}
public void SetUpFixture()
{
project = WebReferenceTestHelper.CreateTestProject("C#");
project.FileName = FileName.Create("C:\\projects\\test\\foo.csproj");
protocol = new DiscoveryClientProtocol();
DiscoveryDocumentReference discoveryRef = new DiscoveryDocumentReference();
discoveryRef.Url = updateFromUrl;
protocol.References.Add(discoveryRef);
ContractReference contractRef = new ContractReference();
contractRef.Url = "http://localhost/test.asmx?wsdl";
contractRef.ClientProtocol = new DiscoveryClientProtocol();
ServiceDescription desc = new ServiceDescription();
contractRef.ClientProtocol.Documents.Add(contractRef.Url, desc);
protocol.References.Add(contractRef);
WebReferenceTestHelper.InitializeProjectBindings();
webReference = new SD.WebReference(project, updateFromUrl, name, proxyNamespace, protocol);
webReferenceUrl = webReference.WebReferenceUrl;
discoFileProjectItem = WebReferenceTestHelper.GetFileProjectItem(webReference.Items, "Web References\\localhost\\test.disco", ItemType.None);
referenceMapFileProjectItem = WebReferenceTestHelper.GetFileProjectItem(webReference.Items, "Web References\\localhost\\Reference.map", ItemType.None);
wsdlFileProjectItem = WebReferenceTestHelper.GetFileProjectItem(webReference.Items, "Web References\\localhost\\test.wsdl", ItemType.None);
proxyFileProjectItem = WebReferenceTestHelper.GetFileProjectItem(webReference.Items, "Web References\\localhost\\Reference.cs", ItemType.Compile);
webReferencesProjectItem = (WebReferencesProjectItem)WebReferenceTestHelper.GetProjectItem(webReference.Items, "Web References\\", ItemType.WebReferences);
webServicesReferenceProjectItem = (ReferenceProjectItem)WebReferenceTestHelper.GetProjectItem(webReference.Items, ItemType.Reference);
}
public void Init()
{
// Create a project to display.
project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
// Add a test class.
projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
MockClass c = new MockClass("RootNamespace.MyTestFixture");
c.Attributes.Add(new MockAttribute("TestFixture"));
c.ProjectContent = projectContent;
projectContent.Classes.Add(c);
// Add a second class with the same name.
MockClass secondTestClass = new MockClass("RootNamespace.MyTestFixture");
secondTestClass.ProjectContent = projectContent;
secondTestClass.Attributes.Add(new MockAttribute("TestFixture"));
projectContent.Classes.Add(secondTestClass);
testProject = new TestProject(project, projectContent);
}
/// <summary>
/// Determines whether the specified reference is a reference to
/// a test framework. Currently only references to the
/// NUnit.Framework return true.
/// </summary>
public static bool IsTestFrameworkReference(ReferenceProjectItem referenceProjectItem)
{
if (referenceProjectItem != null) {
return string.Equals(referenceProjectItem.ShortName, "NUnit.Framework", StringComparison.OrdinalIgnoreCase);
}
return false;
}
public void SetUpFixture()
{
WixProject p = WixBindingTestsHelper.CreateEmptyWixProject();
FileProjectItem item = new FileProjectItem(p, ItemType.None);
item.Include = "readme.txt";
ProjectService.AddProjectItem(p, item);
ReferenceProjectItem referenceItem = new ReferenceProjectItem(p);
referenceItem.Include = "System.Windows.Forms";
ProjectService.AddProjectItem(p, referenceItem);
item = new FileProjectItem(p, ItemType.Compile);
item.Include = "setup.wxs";
ProjectService.AddProjectItem(p, item);
item = new FileProjectItem(p, ItemType.Compile);
item.Include = "test.wxi";
ProjectService.AddProjectItem(p, item);
item = new FileProjectItem(p, ItemType.Compile);
item.Include = "dialogs.wxs";
ProjectService.AddProjectItem(p, item);
wixFileProjectItemCount = 0;
foreach (FileProjectItem fileItem in p.WixSourceFiles) {
wixFileProjectItemCount++;
}
wixSetupFile = p.WixSourceFiles[0];
wixDialogsFile = p.WixSourceFiles[1];
}
public void SetUp()
{
solution = new Solution();
// Create a project to display in the test tree view.
project = new MockCSharpProject(solution, "TestProject");
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
// Add a test class with a TestFixture attributes.
projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
testClass1 = new MockClass(projectContent, "Project.Tests.MyTestFixture");
testClass1.Attributes.Add(new MockAttribute("TestFixture"));
projectContent.Classes.Add(testClass1);
testClass2 = new MockClass(projectContent, "Project.MyTestFixture");
testClass2.Attributes.Add(new MockAttribute("TestFixture"));
projectContent.Classes.Add(testClass2);
testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport();
dummyTreeView = new DummyParserServiceTestTreeView(testFrameworks);
dummyTreeView.ProjectContentForProject = projectContent;
// Load the projects into the test tree view.
treeView = dummyTreeView as TestTreeView;
solution.Folders.Add(project);
treeView.AddSolution(solution);
nodes = treeView.Nodes;
rootNode = (ExtTreeNode)treeView.Nodes[0];
treeView.SelectedNode = rootNode;
testProject = treeView.SelectedTestProject;
}
public void Init()
{
// Create a project to display in the test tree view.
IProject project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
// Add a test class with a TestFixture attributes.
MockProjectContent projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
MockClass c = new MockClass("RootNamespace.MyTestFixture");
c.Namespace = "RootNamespace";
c.Attributes.Add(new MockAttribute("TestFixture"));
c.ProjectContent = projectContent;
projectContent.Classes.Add(c);
// Add a second class no root namespace.
c = new MockClass("MyTestFixture2");
c.Namespace = String.Empty;
c.Attributes.Add(new MockAttribute("TestFixture"));
c.ProjectContent = projectContent;
projectContent.Classes.Add(c);
testProject = new TestProject(project, projectContent);
}
public void SetUpFixture()
{
project = WebReferenceTestHelper.CreateTestProject("C#");
project.FileName = "C:\\projects\\test\\foo.csproj";
ReferenceProjectItem referenceItem = new ReferenceProjectItem(project, "System.Web.Services");
ProjectService.AddProjectItem(project, referenceItem);
protocol = new DiscoveryClientProtocol();
DiscoveryDocumentReference discoveryRef = new DiscoveryDocumentReference();
discoveryRef.Url = updateFromUrl;
protocol.References.Add(discoveryRef);
ContractReference contractRef = new ContractReference();
contractRef.Url = "http://localhost/test.asmx?wsdl";
contractRef.ClientProtocol = new DiscoveryClientProtocol();
ServiceDescription desc = new ServiceDescription();
contractRef.ClientProtocol.Documents.Add(contractRef.Url, desc);
protocol.References.Add(contractRef);
WebReferenceTestHelper.InitializeLanguageBindings();
webReference = new SD.WebReference(project, updateFromUrl, name, proxyNamespace, protocol);
webServicesReferenceProjectItem = (ReferenceProjectItem)WebReferenceTestHelper.GetProjectItem(webReference.Items, ItemType.Reference);
}
public void Init()
{
solution = new Solution();
project1 = new MockCSharpProject(solution);
project1.Name = "A";
ReferenceProjectItem refProjectItem = new ReferenceProjectItem(project1);
refProjectItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project1, refProjectItem);
solution.Folders.Add(project1);
project2 = new MockCSharpProject(solution);
project2.Name = "Z";
refProjectItem = new ReferenceProjectItem(project2);
refProjectItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project2, refProjectItem);
solution.Folders.Add(project2);
MockProjectContent projectContent = new MockProjectContent();
projectContent.Project = project1;
treeView = new DummyParserServiceTestTreeView();
treeView.ProjectContentForProject = projectContent;
treeView.AddSolution(solution);
projects = treeView.GetProjects();
}
public override void FixtureSetUp()
{
base.FixtureSetUp();
// Set up the project.
MSBuildBasedProject project = WebReferenceTestHelper.CreateTestProject("C#");
project.FileName = FileName.Create("c:\\projects\\test\\foo.csproj");
// Web references item.
WebReferencesProjectItem webReferencesItem = new WebReferencesProjectItem(project);
webReferencesItem.Include = "Web References\\";
ProjectService.AddProjectItem(project, webReferencesItem);
// Web reference url.
WebReferenceUrl webReferenceUrl = new WebReferenceUrl(project);
webReferenceUrl.Include = "http://localhost/test.asmx";
webReferenceUrl.UpdateFromURL = "http://localhost/test.asmx";
webReferenceUrl.RelPath = "Web References\\localhost";
ProjectService.AddProjectItem(project, webReferenceUrl);
FileProjectItem discoFileItem = new FileProjectItem(project, ItemType.None);
discoFileItem.Include = "Web References\\localhost\\test.disco";
ProjectService.AddProjectItem(project, discoFileItem);
FileProjectItem wsdlFileItem = new FileProjectItem(project, ItemType.None);
wsdlFileItem.Include = "Web References\\localhost\\test.wsdl";
ProjectService.AddProjectItem(project, wsdlFileItem);
// Proxy
FileProjectItem proxyItem = new FileProjectItem(project, ItemType.Compile);
proxyItem.Include = "Web References\\localhost\\Reference.cs";
proxyItem.DependentUpon = "Reference.map";
ProjectService.AddProjectItem(project, proxyItem);
// Reference map.
FileProjectItem mapItem = new FileProjectItem(project, ItemType.None);
mapItem.Include = "Web References\\localhost\\Reference.map";
ProjectService.AddProjectItem(project, mapItem);
// System.Web.Services reference.
ReferenceProjectItem webServicesReferenceItem = new ReferenceProjectItem(project, "System.Web.Services");
ProjectService.AddProjectItem(project, webServicesReferenceItem);
// Set up the web reference.
DiscoveryClientProtocol protocol = new DiscoveryClientProtocol();
DiscoveryDocumentReference discoveryRef = new DiscoveryDocumentReference();
discoveryRef.Url = "http://localhost/new.asmx";
protocol.References.Add(discoveryRef);
ContractReference contractRef = new ContractReference();
contractRef.Url = "http://localhost/new.asmx?wsdl";
contractRef.ClientProtocol = new DiscoveryClientProtocol();
ServiceDescription desc = new ServiceDescription();
contractRef.ClientProtocol.Documents.Add(contractRef.Url, desc);
protocol.References.Add(contractRef);
WebReferenceTestHelper.InitializeProjectBindings();
var webReference = new Gui.WebReference(project, "http://localhost/new.asmx", "localhost", "ProxyNamespace", protocol);
changes = webReference.GetChanges(project);
}
public void Init()
{
resultChangedCalled = false;
IProject project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
MockClass mockClass = new MockClass("RootNamespace.Tests.MyTestFixture");
mockClass.Namespace = "RootNamespace.Tests";
mockClass.ProjectContent = projectContent;
mockClass.Attributes.Add(new MockAttribute("TestFixture"));
projectContent.Classes.Add(mockClass);
// Add a method to the test class
MockMethod mockMethod = new MockMethod("TestMethod");
mockMethod.DeclaringType = mockClass;
mockMethod.Attributes.Add(new MockAttribute("Test"));
mockClass.Methods.Add(mockMethod);
testProject = new TestProject(project, projectContent);
testClass = testProject.TestClasses[0];
testMethod = testClass.TestMethods[0];
}
public void SetUp()
{
testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport();
treeView = new DummyParserServiceTestTreeView(testFrameworks);
// Create a solution with two test projects.
solution = new Solution(new MockProjectChangeWatcher());
// Create the first test project.
firstProject = new MockCSharpProject(solution, "FirstTestProject");
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(firstProject);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(firstProject, nunitFrameworkReferenceItem);
// Create the second test project.
secondProject = new MockCSharpProject(solution, "SecondTestProject");
nunitFrameworkReferenceItem = new ReferenceProjectItem(secondProject);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(secondProject, nunitFrameworkReferenceItem);
// Add the projects to the solution.
solution.Folders.Add(firstProject);
solution.Folders.Add(secondProject);
// Create a dummy project content so the projects will be added
// to the tree.
treeView.ProjectContentForProject = new MockProjectContent();
// Add the solution to the tree.
treeView.AddSolution(solution);
allTestsTreeNode = treeView.Nodes[0] as AllTestsTreeNode;
firstTestProject = treeView.GetTestProject(firstProject);
secondTestProject = treeView.GetTestProject(secondProject);
}
ReferenceProjectItem CreateReference(string referencePath)
{
var assemblyReference = new ReferenceProjectItem(project);
assemblyReference.Include = Path.GetFileNameWithoutExtension(referencePath);
assemblyReference.HintPath = referencePath;
return assemblyReference;
}
public void Init()
{
IProject project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
MockProjectContent projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
mockClass = new MockClass(projectContent, "RootNamespace.Tests.MyTestFixture");
mockClass.Attributes.Add(new MockAttribute("TestFixture"));
projectContent.Classes.Add(mockClass);
// Add a method to the test class
MockMethod mockMethod = new MockMethod(mockClass, "TestMethod1");
mockMethod.Attributes.Add(new MockAttribute("Test"));
mockClass.Methods.Add(mockMethod);
mockMethod = new MockMethod(mockClass, "TestMethod2");
mockMethod.Attributes.Add(new MockAttribute("Test"));
mockClass.Methods.Add(mockMethod);
testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport();
testProject = new TestProject(project, projectContent, testFrameworks);
testClass = testProject.TestClasses[0];
testMethod1 = testClass.TestMembers[0];
testMethod2 = testClass.TestMembers[1];
}
void CreateReference(string name)
{
project = new TestableDTEProject();
msbuildProject = project.TestableProject;
referenceProjectItem = msbuildProject.AddReference(name);
fakeProjectService = project.FakeProjectService;
CreateReference(project, referenceProjectItem);
}
public void WebServicesReferenceDoesNotExist1()
{
MSBuildBasedProject project = WebReferenceTestHelper.CreateTestProject("C#");
ReferenceProjectItem referenceItem = new ReferenceProjectItem(project, "System.Windows.Forms");
ProjectService.AddProjectItem(project, referenceItem);
Assert.IsFalse(SD.WebReference.ProjectContainsWebServicesReference(project));
}
public void WebServicesReferenceExists1()
{
MSBuildBasedProject project = WebReferenceTestHelper.CreateTestProject("C#");
ReferenceProjectItem referenceItem = new ReferenceProjectItem(project, "system.web.services");
ProjectService.AddProjectItem(project, referenceItem);
Assert.IsTrue(SD.WebReference.ProjectContainsWebServicesReference(project));
}
public void Run(IProject project)
{
if (project != null) {
ReferenceProjectItem nunitRef = new ReferenceProjectItem(project, "nunit.framework");
ProjectService.AddProjectItem(project, nunitRef);
project.Save();
}
}
bool IsNUnitFrameworkAssemblyReference(ReferenceProjectItem referenceProjectItem)
{
if (referenceProjectItem != null) {
string name = referenceProjectItem.ShortName;
return name.Equals("NUnit.Framework", StringComparison.OrdinalIgnoreCase);
}
return false;
}
public void ProjectWithNUnitFrameworkReferenceCaseInsensitive()
{
IProject project = new MockCSharpProject();
ReferenceProjectItem referenceProjectItem = new ReferenceProjectItem(project);
referenceProjectItem.Include = "nunit.framework";
ProjectService.AddProjectItem(project, referenceProjectItem);
Assert.IsTrue(TestProject.IsTestProject(project));
}
public ReferenceNode(ReferenceProjectItem item)
{
this.item = item;
Text = item.Name;
SetIcon("Icons.16x16.Reference");
Nodes.Add(new TreeNode(StringParser.Parse("${res:ICSharpCode.SharpDevelop.Gui.Pads.ClassScout.LoadingNode}")));
}
public void IsTestProjectReturnsTrueForProjectWithMbUnitFrameworkAssemblyReferenceIgnoringCase()
{
MockCSharpProject project = new MockCSharpProject();
ReferenceProjectItem nunitFrameworkRef = new ReferenceProjectItem(project, "MBUNIT");
ProjectService.AddProjectItem(project, nunitFrameworkRef);
Assert.IsTrue(testFramework.IsTestProject(project));
}
public void IsTestProjectReturnsTrueForProjectWithNUnitFrameworkAssemblyReferenceUsingFullName()
{
MockCSharpProject project = new MockCSharpProject();
string assemblyName = "nunit.framework, Version=2.5.3.9345, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77";
ReferenceProjectItem nunitFrameworkRef = new ReferenceProjectItem(project, assemblyName);
ProjectService.AddProjectItem(project, nunitFrameworkRef);
Assert.IsTrue(testFramework.IsTestProject(project));
}
public ReferenceNode(ReferenceProjectItem referenceProjectItem)
{
this.referenceProjectItem = referenceProjectItem;
Tag = referenceProjectItem;
ContextmenuAddinTreePath = "/SharpDevelop/Pads/ProjectBrowser/ContextMenu/ReferenceNode";
SetIcon("Icons.16x16.Reference");
Text = referenceProjectItem.ShortName;
}
public void ProjectWithNUnitFrameworkReferenceSpecificVersion()
{
IProject project = new MockCSharpProject();
ReferenceProjectItem referenceProjectItem = new ReferenceProjectItem(project);
referenceProjectItem.Include = "NUnit.Framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77";
ProjectService.AddProjectItem(project, referenceProjectItem);
Assert.IsTrue(TestProject.IsTestProject(project));
}
protected override ParseProjectContent CreateProjectContent()
{
ParseProjectContent pc = base.CreateProjectContent();
ReferenceProjectItem vbRef = new ReferenceProjectItem(this, "Microsoft.VisualBasic");
if (vbRef != null) {
pc.AddReferencedContent(AssemblyParserService.GetProjectContentForReference(vbRef));
}
MyNamespaceBuilder.BuildNamespace(this, pc);
return pc;
}
void CreateReference(string name)
{
project = new TestableDTEProject();
msbuildProject = project.TestableProject;
referenceProjectItem = msbuildProject.AddReference(name);
fakeProjectService = project.FakeProjectService;
CreateReference(project, referenceProjectItem);
IWorkbench workbench = MockRepository.GenerateStub<IWorkbench>();
ICSharpCode.SharpDevelop.SD.Services.AddService(typeof(IWorkbench), workbench);
}
static string[] GetReferenceProjectItemAsStrings(ReferenceProjectItem referenceItem)
{
if (referenceItem == null) {
return new string[2];
}
return new string[] {
"Include: " + referenceItem.Include,
"HintPath: " + referenceItem.HintPath
};
}
public void Init()
{
project = new MockCSharpProject();
command.Run(project);
if (project.Items.Count > 0) {
referenceProjectItem = project.Items[0] as ReferenceProjectItem;
}
}
void AddReferenceIfNotExists(string name, string requiredTargetFramework)
{
if (!(Project.GetItemsOfType(ItemType.Reference).Any(r => string.Equals(r.Include, name, StringComparison.OrdinalIgnoreCase))))
{
ReferenceProjectItem rpi = new ReferenceProjectItem(Project, name);
if (requiredTargetFramework != null)
{
rpi.SetMetadata("RequiredTargetFramework", requiredTargetFramework);
}
ProjectService.AddProjectItem(Project, rpi);
}
}
public ReferenceNode(ReferenceProjectItem referenceProjectItem)
{
this.referenceProjectItem = referenceProjectItem;
Tag = referenceProjectItem;
ContextmenuAddinTreePath = "/SharpDevelop/Pads/ProjectBrowser/ContextMenu/ReferenceNode";
SetIcon("Icons.16x16.Reference");
Text = referenceProjectItem.ShortName;
this.PerformInitialization();
ParserService.LoadSolutionProjectsThreadEnded += delegate { ShowNamespaces(); };
}
public ReferenceNode(ReferenceProjectItem referenceProjectItem)
{
this.referenceProjectItem = referenceProjectItem;
Tag = referenceProjectItem;
ContextmenuAddinTreePath = "/SharpDevelop/Pads/ProjectBrowser/ContextMenu/ReferenceNode";
SetIcon("Icons.16x16.Reference");
if (referenceProjectItem.ItemType == ItemType.ProjectReference)
{
Text = Path.GetFileNameWithoutExtension(referenceProjectItem.Include);
}
else
{
Text = referenceProjectItem.Name;
}
}
protected internal virtual void AddDotnet35References()
{
ReferenceProjectItem rpi = new ReferenceProjectItem(this, "System.Core");
rpi.SetMetadata("RequiredTargetFramework", "3.5");
ProjectService.AddProjectItem(this, rpi);
if (GetItemsOfType(ItemType.Reference).Any(r => r.Include == "System.Data"))
{
rpi = new ReferenceProjectItem(this, "System.Data.DataSetExtensions");
rpi.SetMetadata("RequiredTargetFramework", "3.5");
ProjectService.AddProjectItem(this, rpi);
}
if (GetItemsOfType(ItemType.Reference).Any(r => r.Include == "System.Xml"))
{
rpi = new ReferenceProjectItem(this, "System.Xml.Linq");
rpi.SetMetadata("RequiredTargetFramework", "3.5");
ProjectService.AddProjectItem(this, rpi);
}
}
/// <summary>
/// Resolves the location of the reference files.
/// </summary>
/// <param name="baseProject">The base project.</param>
/// <param name="referenceReplacements">A different set of references to use instead of those in the project.
/// Used by the GacReferencePanel.</param>
public static IList <ReferenceProjectItem> ResolveAssemblyReferences(
MSBuildBasedProject baseProject,
ReferenceProjectItem[] additionalReferences = null, bool resolveOnlyAdditionalReferences = false,
bool logErrorsToOutputPad = true)
{
ProjectInstance project = baseProject.CreateProjectInstance();
project.SetProperty("BuildingProject", "false");
project.SetProperty("DesignTimeBuild", "true");
List <ProjectItemInstance> references = (
from item in project.Items
where ItemType.ReferenceItemTypes.Contains(new ItemType(item.ItemType))
select item
).ToList();
List <ReferenceProjectItem> referenceProjectItems;
if (resolveOnlyAdditionalReferences)
{
// Remove existing references from project
foreach (ProjectItemInstance reference in references)
{
project.RemoveItem(reference);
}
references.Clear();
referenceProjectItems = new List <ReferenceProjectItem>();
}
else
{
// Remove the "Private" meta data.
// This is necessary to detect the default value for "Private"
foreach (ProjectItemInstance reference in references)
{
reference.RemoveMetadata("Private");
}
referenceProjectItems = baseProject.Items.OfType <ReferenceProjectItem>().ToList();
}
if (additionalReferences != null)
{
referenceProjectItems.AddRange(additionalReferences);
foreach (ReferenceProjectItem item in additionalReferences)
{
references.Add(project.AddItem("Reference", item.Include));
}
}
List <string> targets = new List <string>();
if (baseProject.HasProjectType(ProjectTypeGuids.PortableLibrary))
{
targets.Add("ResolveReferences");
targets.Add("DesignTimeResolveAssemblyReferences");
}
else
{
targets.Add("ResolveAssemblyReferences");
}
BuildRequestData requestData = new BuildRequestData(project, targets.ToArray(), new HostServices());
List <ILogger> loggers = new List <ILogger>();
//loggers.Add(new ConsoleLogger(LoggerVerbosity.Diagnostic));
if (logErrorsToOutputPad)
{
loggers.Add(new SimpleErrorLogger());
}
lock (SolutionProjectCollectionLock) {
BuildParameters parameters = new BuildParameters(baseProject.MSBuildProjectCollection);
parameters.Loggers = loggers;
LoggingService.Debug("Started build for ResolveAssemblyReferences");
BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, requestData);
if (result == null)
{
throw new InvalidOperationException("BuildResult is null");
}
LoggingService.Debug("Build for ResolveAssemblyReferences finished: " + result.OverallResult);
}
IEnumerable <ProjectItemInstance> resolvedAssemblyProjectItems = project.GetItems("_ResolveAssemblyReferenceResolvedFiles");
var query =
from msbuildItem in resolvedAssemblyProjectItems
let originalInclude = msbuildItem.GetMetadataValue("OriginalItemSpec")
join item in referenceProjectItems.Where(p => p.ItemType != ItemType.ProjectReference) on originalInclude equals item.Include into referenceItems
select new {
OriginalInclude = originalInclude,
AssemblyName = new DomAssemblyName(msbuildItem.GetMetadataValue("FusionName")),
FullPath = FileUtility.GetAbsolutePath(baseProject.Directory, msbuildItem.GetMetadataValue("Identity")),
Redist = msbuildItem.GetMetadataValue("Redist"),
CopyLocal = bool.Parse(msbuildItem.GetMetadataValue("CopyLocal")),
ReferenceItems = referenceItems
};
// HACK: mscorlib is reported twice for portable library projects (even if we don't specify it as additionalReference)
query = query.DistinctBy(asm => asm.FullPath);
List <ReferenceProjectItem> resolvedAssemblies = new List <ReferenceProjectItem>();
List <ReferenceProjectItem> handledReferenceItems = new List <ReferenceProjectItem>();
foreach (var assembly in query)
{
LoggingService.Debug("Got information about " + assembly.OriginalInclude + "; fullpath=" + assembly.FullPath);
foreach (var referenceItem in assembly.ReferenceItems)
{
referenceItem.AssemblyName = assembly.AssemblyName;
referenceItem.FileName = assembly.FullPath;
referenceItem.Redist = assembly.Redist;
referenceItem.DefaultCopyLocalValue = assembly.CopyLocal;
handledReferenceItems.Add(referenceItem);
}
ReferenceProjectItem firstItem = assembly.ReferenceItems.FirstOrDefault();
if (firstItem != null)
{
resolvedAssemblies.Add(firstItem);
}
else
{
resolvedAssemblies.Add(new ReferenceProjectItem(baseProject, assembly.OriginalInclude)
{
FileName = assembly.FullPath
});
}
}
// Add any assemblies that weren't resolved yet. This is important - for example, this adds back project references.
foreach (var referenceItem in referenceProjectItems.Except(handledReferenceItems))
{
resolvedAssemblies.Add(referenceItem);
}
return(resolvedAssemblies);
}
