|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Xml;
using Microsoft.Build.Construction;
using Microsoft.Build.Evaluation;
using Microsoft.Build.Execution;
using Microsoft.Build.Shared;
using Microsoft.Build.Utilities;
using Shouldly;
using Xunit;
using Xunit.Abstractions;
using InvalidProjectFileException = Microsoft.Build.Exceptions.InvalidProjectFileException;
#nullable disable
namespace Microsoft.Build.UnitTests.OM.Definition
{
/// <summary>
/// Tests for ProjectCollection
/// </summary>
public class ProjectCollection_Tests : IDisposable
{
/// <summary>
/// Gets or sets the test context.
/// </summary>
public ITestOutputHelper TestOutput { get; set; }
public ProjectCollection_Tests(ITestOutputHelper outputHelper)
{
TestOutput = outputHelper;
ProjectCollection.GlobalProjectCollection.UnloadAllProjects();
}
/// <summary>
/// Clear out the global project collection
/// </summary>
public void Dispose()
{
ProjectCollection.GlobalProjectCollection.UnloadAllProjects();
Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count);
IDictionary<string, string> globalProperties = ProjectCollection.GlobalProjectCollection.GlobalProperties;
foreach (string propertyName in globalProperties.Keys)
{
ProjectCollection.GlobalProjectCollection.RemoveGlobalProperty(propertyName);
}
Assert.Empty(ProjectCollection.GlobalProjectCollection.GlobalProperties);
}
/// <summary>
/// Add a single project from disk and verify it's put in the global project collection
/// </summary>
[Fact]
public void AddProjectFromDisk()
{
string path = null;
try
{
path = FileUtilities.GetTemporaryFileName();
ProjectRootElement xml = ProjectRootElement.Create(path);
xml.Save();
Project project = new Project(path);
Project project2 = ProjectCollection.GlobalProjectCollection.LoadProject(path);
Assert.True(ReferenceEquals(project, project2));
}
finally
{
if (path != null)
{
File.Delete(path);
}
}
}
/// <summary>
/// When an unnamed project is saved, it gets a name, and should be entered into
/// the appropriate project collection.
/// </summary>
[Fact]
public void AddProjectOnSave()
{
string path = null;
try
{
Project project = new Project();
Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count);
path = FileUtilities.GetTemporaryFileName();
project.Save(path);
Project project2 = ProjectCollection.GlobalProjectCollection.LoadProject(path);
Assert.True(ReferenceEquals(project, project2));
}
finally
{
if (path != null)
{
File.Delete(path);
}
}
}
/// <summary>
/// When an unnamed project is saved, it gets a name, and should be entered into
/// the appropriate project collection.
/// </summary>
[Fact]
public void AddProjectOnSave_SpecifiedProjectCollection()
{
string path = null;
try
{
using ProjectCollection collection = new ProjectCollection();
Project project = new Project(collection);
path = FileUtilities.GetTemporaryFileName();
project.Save(path);
Project project2 = collection.LoadProject(path);
Assert.True(ReferenceEquals(project, project2));
}
finally
{
if (path != null)
{
File.Delete(path);
}
}
}
/// <summary>
/// When an unnamed project is given a name, it should be entered into its
/// project collection.
/// </summary>
[Fact]
public void AddProjectOnSetName()
{
var project = new Project { FullPath = "c:\\x" };
Project project2 = ProjectCollection.GlobalProjectCollection.LoadProject("c:\\x");
Assert.True(ReferenceEquals(project, project2));
}
/// <summary>
/// Loading a project from a file inherits the project collection's global properties
/// </summary>
[Fact]
public void GlobalPropertyInheritLoadFromFile()
{
string path = null;
try
{
path = CreateProjectFile();
using var collection = new ProjectCollection();
collection.SetGlobalProperty("p", "v");
Project project = collection.LoadProject(path);
Assert.Equal("v", project.GlobalProperties["p"]);
}
finally
{
if (path != null)
{
File.Delete(path);
}
}
}
/// <summary>
/// Loading a project from a file inherits the project collection's global properties
/// </summary>
#if FEATURE_INSTALLED_MSBUILD
[Fact]
#else
[Fact(Skip = "https://github.com/dotnet/msbuild/issues/276")]
#endif
public void GlobalPropertyInheritLoadFromFile2()
{
string path = null;
try
{
path = CreateProjectFile();
using ProjectCollection collection = new ProjectCollection();
collection.SetGlobalProperty("p", "v");
Project project = collection.LoadProject(path, "4.0");
Assert.Equal("v", project.GlobalProperties["p"]);
}
finally
{
if (path != null)
{
File.Delete(path);
}
}
}
/// <summary>
/// Loading a project from a file inherits the project collection's global properties
/// </summary>
#if FEATURE_INSTALLED_MSBUILD
[Fact]
#else
[Fact(Skip = "https://github.com/dotnet/msbuild/issues/276")]
#endif
public void GlobalPropertyInheritLoadFromFile3()
{
string path = null;
try
{
path = CreateProjectFile();
using ProjectCollection collection = new ProjectCollection();
collection.SetGlobalProperty("p", "v");
Project project = collection.LoadProject(path, null, "4.0");
Assert.Equal("v", project.GlobalProperties["p"]);
}
finally
{
if (path != null)
{
File.Delete(path);
}
}
}
/// <summary>
/// Loading a project from a reader inherits the project collection's global properties
/// </summary>
[Fact]
public void GlobalPropertyInheritLoadFromXml1()
{
using XmlReader reader = CreateProjectXmlReader();
using var collection = new ProjectCollection();
collection.SetGlobalProperty("p", "v");
Project project = collection.LoadProject(reader);
Assert.Equal("v", project.GlobalProperties["p"]);
}
/// <summary>
/// Loading a project from a reader inherits the project collection's global properties
/// </summary>
[Fact]
public void GlobalPropertyInheritLoadFromXml2()
{
using XmlReader reader = CreateProjectXmlReader();
using var collection = new ProjectCollection();
collection.SetGlobalProperty("p", "v");
Project project = collection.LoadProject(reader, ObjectModelHelpers.MSBuildDefaultToolsVersion);
Assert.Equal("v", project.GlobalProperties["p"]);
}
/// <summary>
/// Creating a project inherits the project collection's global properties
/// </summary>
[Fact]
public void GlobalPropertyInheritProjectConstructor()
{
using var collection = new ProjectCollection();
collection.SetGlobalProperty("p", "v");
var project = new Project(collection);
Assert.Equal("v", project.GlobalProperties["p"]);
}
/// <summary>
/// Load project should load a project, if it wasn't already loaded.
/// </summary>
[Fact]
public void GetLoadedProjectNonExistent()
{
string path = null;
try
{
path = FileUtilities.GetTemporaryFileName();
ProjectRootElement xml = ProjectRootElement.Create();
xml.Save(path);
Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count);
ProjectCollection.GlobalProjectCollection.LoadProject(path);
Assert.Equal(1, ProjectCollection.GlobalProjectCollection.Count);
}
finally
{
if (path != null)
{
File.Delete(path);
}
}
}
/// <summary>
/// Verify that one project collection doesn't contain the projects of another
/// </summary>
[Fact]
public void GetLoadedProjectWrongCollection()
{
var project1 = new Project { FullPath = "c:\\1" };
using var collection = new ProjectCollection();
var project2 = new Project(collection) { FullPath = "c:\\1" };
Assert.True(ReferenceEquals(project2, collection.LoadProject("c:\\1")));
Assert.False(ReferenceEquals(project1, collection.LoadProject("c:\\1")));
}
/// <summary>
/// Verify that one project collection doesn't contain the ProjectRootElements of another
/// -- because they don't share a ProjectRootElementCache
/// </summary>
[Fact]
public void GetLoadedProjectRootElementWrongCollection()
{
string path = null;
try
{
path = FileUtilities.GetTemporaryFileName();
ProjectRootElement.Create(path).Save();
using ProjectCollection collection1 = new ProjectCollection();
Project project1 = collection1.LoadProject(path);
Project project1b = collection1.LoadProject(path);
Assert.True(ReferenceEquals(project1.Xml, project1b.Xml));
using ProjectCollection collection2 = new ProjectCollection();
Project project2 = collection2.LoadProject(path);
Assert.False(ReferenceEquals(project1.Xml, project2.Xml));
}
finally
{
if (path != null)
{
File.Delete(path);
}
}
}
/// <summary>
/// Attempt to have two equivalent projects in a project collection fails.
/// </summary>
[Fact]
public void ErrorTwoProjectsEquivalentOneCollection()
{
_ = new Project { FullPath = "c:\\x" };
Assert.Throws<InvalidOperationException>(() =>
{
_ = new Project { FullPath = "c:\\x" };
});
}
/// <summary>
/// Validates that when loading two projects with nominally different global properties, but that match when we take
/// into account the ProjectCollection's global properties, we get the pre-existing project if one exists.
/// </summary>
[Fact]
public void TwoProjectsEquivalentWhenOneInheritsFromProjectCollection()
{
var project = new Project { FullPath = "c:\\1" };
// Set a global property on the project collection -- this should be passed on to all
// loaded projects.
ProjectCollection.GlobalProjectCollection.SetGlobalProperty("Configuration", "Debug");
Assert.Equal("Debug", project.GlobalProperties["Configuration"]);
// now create a global properties dictionary to pass to a new project
var globals = new Dictionary<string, string> { { "Configuration", "Debug" } };
ProjectCollection.GlobalProjectCollection.LoadProject("c:\\1", globals, null);
Assert.Equal(1, ProjectCollection.GlobalProjectCollection.Count);
}
/// <summary>
/// Two projects may have the same path but different global properties.
/// </summary>
[Fact]
public void TwoProjectsDistinguishedByGlobalPropertiesOnly()
{
ProjectRootElement xml = ProjectRootElement.Create();
string projectDirectory = NativeMethodsShared.IsWindows ? "c:\\1" : "/l";
var globalProperties1 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "p", "v1" } };
var project1 =
new Project(xml, globalProperties1, ObjectModelHelpers.MSBuildDefaultToolsVersion)
{
FullPath = projectDirectory
};
var globalProperties2 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "p", "v2" } };
var project2 =
new Project(xml, globalProperties2, ObjectModelHelpers.MSBuildDefaultToolsVersion)
{
FullPath = projectDirectory
};
Assert.True(ReferenceEquals(project1, ProjectCollection.GlobalProjectCollection.LoadProject(projectDirectory, globalProperties1, ObjectModelHelpers.MSBuildDefaultToolsVersion)));
Assert.True(ReferenceEquals(project2, ProjectCollection.GlobalProjectCollection.LoadProject(projectDirectory, globalProperties2, ObjectModelHelpers.MSBuildDefaultToolsVersion)));
List<Project> projects = Helpers.MakeList(ProjectCollection.GlobalProjectCollection.LoadedProjects);
Assert.Equal(2, projects.Count);
Assert.Equal(2, ProjectCollection.GlobalProjectCollection.Count);
Assert.Contains(project1, projects);
Assert.Contains(project2, projects);
}
/// <summary>
/// Validates that we can correctly load two of the same project file with different global properties, even when
/// those global properties are applied to the project by the project collection (and then overridden in one case).
/// </summary>
[Fact]
public void TwoProjectsDistinguishedByGlobalPropertiesOnly_ProjectOverridesProjectCollection()
{
var project = new Project { FullPath = "c:\\1" };
// Set a global property on the project collection -- this should be passed on to all
// loaded projects.
ProjectCollection.GlobalProjectCollection.SetGlobalProperty("Configuration", "Debug");
Assert.Equal("Debug", project.GlobalProperties["Configuration"]);
// Differentiate this project from the one below
project.SetGlobalProperty("MyProperty", "MyValue");
// now create a global properties dictionary to pass to a new project
var project2Globals =
new Dictionary<string, string> { { "Configuration", "Release" }, { "Platform", "Win32" } };
Project project2 = ProjectCollection.GlobalProjectCollection.LoadProject("c:\\1", project2Globals, null);
Assert.Equal("Release", project2.GlobalProperties["Configuration"]);
// Setting a global property on the project collection overrides all contained projects,
// whether they were initially loaded with the global project collection's value or not.
ProjectCollection.GlobalProjectCollection.SetGlobalProperty("Platform", "X64");
Assert.Equal("X64", project.GlobalProperties["Platform"]);
Assert.Equal("X64", project2.GlobalProperties["Platform"]);
// But setting a global property on the project directly should override that.
project2.SetGlobalProperty("Platform", "Itanium");
Assert.Equal("Itanium", project2.GlobalProperties["Platform"]);
// Now set global properties such that the two projects have an identical set.
ProjectCollection.GlobalProjectCollection.SetGlobalProperty("Configuration", "Debug2");
ProjectCollection.GlobalProjectCollection.SetGlobalProperty("Platform", "X86");
bool exceptionCaught = false;
try
{
// This will make it identical, so we should get a throw here.
ProjectCollection.GlobalProjectCollection.SetGlobalProperty("MyProperty", "MyValue2");
}
catch (InvalidOperationException)
{
exceptionCaught = true;
}
Assert.True(exceptionCaught); // "Should have caused the two projects to be identical, causing an exception to be thrown"
}
/// <summary>
/// Two projects may have the same path but different tools version.
/// </summary>
[Fact]
public void TwoProjectsDistinguishedByToolsVersionOnly()
{
if (ToolLocationHelper.GetPathToDotNetFramework(TargetDotNetFrameworkVersion.Version35) == null)
{
// "Requires 3.5 to be installed"
return;
}
if (ToolLocationHelper.GetPathToDotNetFramework(TargetDotNetFrameworkVersion.Version20) == null)
{
// ".NET Framework 2.0 is required to be installed for this test, but it is not installed."
return;
}
ProjectRootElement xml = ProjectRootElement.Create();
var project1 = new Project(xml, null, "2.0") { FullPath = "c:\\1" };
var project2 = new Project(xml, null, ObjectModelHelpers.MSBuildDefaultToolsVersion) { FullPath = "c:\\1" };
Assert.True(ReferenceEquals(project1, ProjectCollection.GlobalProjectCollection.LoadProject("c:\\1", null, "2.0")));
Assert.True(ReferenceEquals(project2, ProjectCollection.GlobalProjectCollection.LoadProject("c:\\1", null, ObjectModelHelpers.MSBuildDefaultToolsVersion)));
}
/// <summary>
/// If the ToolsVersion in the project file is bogus, we'll default to the current ToolsVersion and successfully
/// load it. Make sure we can RE-load it, too, and successfully pick up the correct copy of the loaded project.
/// </summary>
[Fact]
public void ReloadProjectWithInvalidToolsVersionInFile()
{
const string content = @"
<Project ToolsVersion='bogus'>
<Target Name='t'/>
</Project>
";
using ProjectFromString projectFromString = new(content);
Project project = projectFromString.Project;
project.FullPath = "c:\\123.proj";
Project project2 = ProjectCollection.GlobalProjectCollection.LoadProject("c:\\123.proj", null, null);
Assert.True(ReferenceEquals(project, project2));
}
/// <summary>
/// Make sure we can reload a project that has a ToolsVersion that doesn't match what it ends up getting
/// forced to by default (current).
/// </summary>
[Fact]
public void ReloadProjectWithProjectToolsVersionDifferentFromEffectiveToolsVersion()
{
const string content = @"
<Project ToolsVersion='4.0'>
<Target Name='t'/>
</Project>
";
using ProjectFromString projectFromString = new(content);
Project project = projectFromString.Project;
project.FullPath = "c:\\123.proj";
Project project2 = ProjectCollection.GlobalProjectCollection.LoadProject("c:\\123.proj", null, null);
Assert.True(ReferenceEquals(project, project2));
}
/// <summary>
/// Collection stores projects distinguished by path, global properties, and tools version.
/// Changing global properties should update the collection.
/// </summary>
[Fact]
public void ChangingGlobalPropertiesUpdatesCollection()
{
using ProjectCollection collection = new ProjectCollection();
var project = new Project(collection) { FullPath = "c:\\x" };
project.SetGlobalProperty("p", "v1"); // should update collection
var globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase) { { "p", "v1" } };
Project newProject = collection.LoadProject("c:\\x", globalProperties, null);
Assert.True(ReferenceEquals(project, newProject));
}
/// <summary>
/// Changing global properties on collection should update the collection's defaults,
/// and any projects even if they have defined the same global properties
/// </summary>
[Fact]
public void SettingGlobalPropertiesOnCollectionUpdatesProjects()
{
using var collection = new ProjectCollection();
var project1 = new Project(collection) { FullPath = "c:\\y" };
Assert.Empty(project1.GlobalProperties);
collection.SetGlobalProperty("g1", "v1");
collection.SetGlobalProperty("g2", "v2");
collection.SetGlobalProperty("g2", "v2"); // try dupe
Assert.Equal(2, project1.GlobalProperties.Count);
collection.RemoveGlobalProperty("g2");
var project2 = new Project(collection) { FullPath = "c:\\x" };
Assert.Single(project1.GlobalProperties);
Assert.Equal("v1", project2.GlobalProperties["g1"]);
Assert.Single(project2.GlobalProperties);
Assert.Equal("v1", project2.GlobalProperties["g1"]);
}
/// <summary>
/// Changing global properties on collection should update the collection's defaults,
/// and any projects even if they have defined the same global properties
/// </summary>
[Fact]
public void SettingGlobalPropertiesOnCollectionUpdatesProjects2()
{
using var collection = new ProjectCollection();
var project1 = new Project(collection) { FullPath = "c:\\y" };
// load into collection
project1.SetGlobalProperty("g1", "v0");
Helpers.ClearDirtyFlag(project1.Xml);
collection.SetGlobalProperty("g1", "v1");
collection.SetGlobalProperty("g2", "v2");
Assert.Equal(2, project1.GlobalProperties.Count);
Assert.Equal("v1", project1.GlobalProperties["g1"]);
Assert.Equal("v2", project1.GlobalProperties["g2"]); // Got overwritten
Assert.True(project1.IsDirty);
}
/// <summary>
/// Changing global properties on collection should update the collection's defaults,
/// and all projects as well
/// </summary>
[Fact]
public void RemovingGlobalPropertiesOnCollectionUpdatesProjects()
{
using var collection = new ProjectCollection();
var project1 = new Project(collection) { FullPath = "c:\\y" };
Assert.Empty(project1.GlobalProperties);
Helpers.ClearDirtyFlag(project1.Xml);
collection.SetGlobalProperty("g1", "v1"); // should make both dirty
collection.SetGlobalProperty("g2", "v2"); // should make both dirty
Assert.True(project1.IsDirty);
var project2 = new Project(collection) { FullPath = "c:\\x" };
Assert.True(project2.IsDirty);
Assert.Equal(2, project1.GlobalProperties.Count);
Assert.Equal("v1", project2.GlobalProperties["g1"]);
Assert.Equal(2, project2.GlobalProperties.Count);
Assert.Equal("v1", project2.GlobalProperties["g1"]);
Helpers.ClearDirtyFlag(project1.Xml);
Helpers.ClearDirtyFlag(project2.Xml);
collection.RemoveGlobalProperty("g2"); // should make both dirty
Assert.True(project1.IsDirty);
Assert.True(project2.IsDirty);
Assert.Single(project1.GlobalProperties);
Assert.Single(project2.GlobalProperties);
collection.RemoveGlobalProperty("g1");
Assert.Empty(project1.GlobalProperties);
Assert.Empty(project2.GlobalProperties);
}
/// <summary>
/// Changing global properties on collection should update the collection's defaults,
/// and all projects as well
/// </summary>
[Fact]
public void RemovingGlobalPropertiesOnCollectionUpdatesProjects2()
{
using var collection = new ProjectCollection();
collection.SetGlobalProperty("g1", "v1");
var project1 = new Project(collection) { FullPath = "c:\\y" };
project1.SetGlobalProperty("g1", "v0"); // mask collection property
Helpers.ClearDirtyFlag(project1.Xml);
collection.RemoveGlobalProperty("g1"); // should modify the project
Assert.Empty(project1.GlobalProperties);
Assert.True(project1.IsDirty);
}
/// <summary>
/// Unloading a project should remove it from the project collection
/// </summary>
[Fact]
public void UnloadProject()
{
var project = new Project { FullPath = "c:\\x" };
Assert.Equal(1, ProjectCollection.GlobalProjectCollection.Count);
ProjectCollection.GlobalProjectCollection.UnloadProject(project); // should not throw
Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count);
Assert.Empty(Helpers.MakeList(ProjectCollection.GlobalProjectCollection.LoadedProjects));
}
/// <summary>
/// Unloading project XML should remove it from the weak cache.
/// </summary>
[Fact]
public void UnloadProjectXml()
{
var project = new Project { FullPath = "c:\\x" };
ProjectRootElement xml = project.Xml;
// Unload the evaluation project, and then the XML.
ProjectCollection.GlobalProjectCollection.UnloadProject(project);
ProjectCollection.GlobalProjectCollection.UnloadProject(xml);
try
{
// If the ProjectRootElement was unloaded from the cache, then
// an attempt to load it by the pretend filename should fail,
// so it makes a good test to see that the UnloadProject method worked.
ProjectCollection.GlobalProjectCollection.LoadProject(xml.FullPath);
Assert.True(false, "An InvalidProjectFileException was expected.");
}
catch (InvalidProjectFileException)
{
}
}
/// <summary>
/// Unloading project XML while it is in use should result in an exception.
/// </summary>
[Fact]
public void UnloadProjectXmlWhileInDirectUse()
{
Assert.Throws<InvalidOperationException>(() =>
{
var project = new Project { FullPath = "c:\\x" };
// Attempt to unload the xml before unloading the project evaluation.
ProjectCollection.GlobalProjectCollection.UnloadProject(project.Xml);
});
}
/// <summary>
/// Unloading project XML while it is in use should result in an exception.
/// </summary>
[Fact]
public void UnloadProjectXmlWhileInImportUse()
{
Assert.Throws<InvalidOperationException>(() =>
{
var mainProject = new Project { FullPath = "c:\\main" };
var importProject = new Project { FullPath = "c:\\import" };
ProjectRootElement importedXml = importProject.Xml;
// Import into main project
mainProject.Xml.PrependChild(mainProject.Xml.CreateImportElement(importProject.FullPath));
mainProject.ReevaluateIfNecessary();
// Unload the import evaluation, but not the main project that still has a reference to it.
ProjectCollection.GlobalProjectCollection.UnloadProject(importProject);
// Attempt to unload the import xml before unloading the project that still references it.
try
{
ProjectCollection.GlobalProjectCollection.UnloadProject(importedXml);
}
catch (InvalidOperationException ex)
{
Console.WriteLine(ex.Message);
throw;
}
});
}
/// <summary>
/// Renaming a project should correctly update the project collection's set of loaded projects.
/// </summary>
[Fact]
public void RenameProject()
{
var project = new Project { FullPath = "c:\\x" };
project.FullPath = "c:\\y";
Assert.Equal(1, ProjectCollection.GlobalProjectCollection.Count);
Assert.True(ReferenceEquals(project, Helpers.MakeList(ProjectCollection.GlobalProjectCollection.LoadedProjects)[0]));
ProjectCollection.GlobalProjectCollection.UnloadProject(project); // should not throw
Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count);
}
/// <summary>
/// Validates that we don't somehow lose the ProjectCollection global properties when renaming the project.
/// </summary>
[Fact]
public void RenameProjectAndVerifyStillContainsProjectCollectionGlobalProperties()
{
var project = new Project { FullPath = "c:\\1" };
// Set a global property on the project collection -- this should be passed on to all
// loaded projects.
ProjectCollection.GlobalProjectCollection.SetGlobalProperty("Configuration", "Debug");
Assert.Equal("Debug", project.GlobalProperties["Configuration"]);
project.FullPath = "c:\\2";
Assert.Equal("Debug", project.GlobalProperties["Configuration"]);
}
/// <summary>
/// Saving a project to a new name should correctly update the project collection's set of loaded projects.
/// Reported by F#.
/// </summary>
[Fact]
public void SaveToNewNameAndUnload()
{
string file1 = null;
string file2 = null;
try
{
file1 = FileUtilities.GetTemporaryFileName();
file2 = FileUtilities.GetTemporaryFileName();
Project project = new Project();
project.Save(file1);
using ProjectCollection collection = new ProjectCollection();
Project project2 = collection.LoadProject(file1);
project2.Save(file2);
collection.UnloadProject(project2);
}
finally
{
if (file1 != null)
{
File.Delete(file1);
}
if (file2 != null)
{
File.Delete(file2);
}
}
}
/// <summary>
/// Saving a project to a new name after loading, unloading, and reloading, should work.
/// Reported by F#.
/// </summary>
[Fact]
public void LoadUnloadReloadSaveToNewName()
{
string file1 = null;
string file2 = null;
try
{
file1 = FileUtilities.GetTemporaryFileName();
file2 = FileUtilities.GetTemporaryFileName();
var project = new Project();
project.Save(file1);
project.ProjectCollection.UnloadProject(project);
using var collection = new ProjectCollection();
Project project2 = collection.LoadProject(file1);
collection.UnloadProject(project2);
Project project3 = collection.LoadProject(file1);
project3.Save(file2); // should not crash
collection.UnloadProject(project3);
}
finally
{
if (file1 != null)
{
File.Delete(file1);
}
if (file2 != null)
{
File.Delete(file2);
}
}
}
/// <summary>
/// Saving a project to a new name after loading, unloading, and reloading, should work.
/// Reported by F#.
/// </summary>
[Fact]
public void LoadUnloadAllReloadSaveToNewName()
{
string file1 = null;
string file2 = null;
try
{
file1 = FileUtilities.GetTemporaryFileName();
file2 = FileUtilities.GetTemporaryFileName();
var project = new Project();
project.Save(file1);
project.ProjectCollection.UnloadProject(project);
using var collection = new ProjectCollection();
collection.LoadProject(file1);
collection.UnloadAllProjects();
Project project3 = collection.LoadProject(file1);
project3.Save(file2); // should not crash
collection.UnloadProject(project3);
}
finally
{
if (file1 != null)
{
File.Delete(file1);
}
if (file2 != null)
{
File.Delete(file2);
}
}
}
/// <summary>
/// Add a toolset
/// </summary>
[Fact]
public void AddToolset()
{
using var collection = new ProjectCollection();
collection.RemoveAllToolsets();
var toolset = new Toolset("x", "c:\\y", collection, null);
collection.AddToolset(toolset);
Assert.Equal(toolset, collection.GetToolset("x"));
Assert.True(collection.ContainsToolset("x"));
List<Toolset> toolsets = Helpers.MakeList(collection.Toolsets);
Assert.Single(toolsets);
Assert.Equal(toolset, toolsets[0]);
}
/// <summary>
/// Add two toolsets
/// </summary>
[Fact]
public void AddTwoToolsets()
{
using var collection = new ProjectCollection();
collection.RemoveAllToolsets();
var toolset1 = new Toolset("x", "c:\\y", collection, null);
var toolset2 = new Toolset("y", "c:\\z", collection, null);
collection.AddToolset(toolset1);
collection.AddToolset(toolset2);
Assert.Equal(toolset1, collection.GetToolset("x"));
Assert.Equal(toolset2, collection.GetToolset("y"));
List<Toolset> toolsets = Helpers.MakeList(collection.Toolsets);
Assert.Equal(2, toolsets.Count);
Assert.Contains(toolset1, toolsets);
Assert.Contains(toolset2, toolsets);
}
/// <summary>
/// Add a toolset that overrides another
/// </summary>
[Fact]
public void ReplaceToolset()
{
using var collection = new ProjectCollection();
collection.RemoveAllToolsets();
var toolset1 = new Toolset("x", "c:\\y", collection, null);
var toolset2 = new Toolset("x", "c:\\z", collection, null);
collection.AddToolset(toolset1);
collection.AddToolset(toolset2);
Assert.Equal(toolset2, collection.GetToolset("x"));
List<Toolset> toolsets = Helpers.MakeList(collection.Toolsets);
Assert.Single(toolsets);
Assert.Equal(toolset2, toolsets[0]);
}
/// <summary>
/// Attempt to add a null toolset
/// </summary>
[Fact]
public void AddNullToolset()
{
Assert.Throws<ArgumentNullException>(() =>
{
ProjectCollection.GlobalProjectCollection.AddToolset(null);
});
}
/// <summary>
/// Remove a toolset
/// </summary>
[Fact]
public void RemoveToolset()
{
using var collection = new ProjectCollection();
var toolset1 = new Toolset("x", "c:\\y", collection, null);
var toolset2 = new Toolset("y", "c:\\z", collection, null);
int initial = Helpers.MakeList(collection.Toolsets).Count;
collection.AddToolset(toolset1);
collection.AddToolset(toolset2);
Assert.True(collection.RemoveToolset("x"));
Assert.False(collection.ContainsToolset("x"));
Assert.Equal(1, Helpers.MakeList(collection.Toolsets).Count - initial);
}
/// <summary>
/// Remove a nonexistent toolset
/// </summary>
[Fact]
public void RemoveNonexistentToolset()
{
using var collection = new ProjectCollection();
Assert.False(collection.RemoveToolset("nonexistent"));
}
/// <summary>
/// Attempt to remove a null tools version
/// </summary>
[Fact]
public void RemoveNullToolsVersion()
{
Assert.Throws<ArgumentNullException>(() =>
{
ProjectCollection.GlobalProjectCollection.RemoveToolset(null);
});
}
/// <summary>
/// Attempt to remove an empty string toolsversion
/// </summary>
[Fact]
public void RemoveEmptyToolsVersion()
{
Assert.Throws<ArgumentException>(() =>
{
ProjectCollection.GlobalProjectCollection.RemoveToolset(String.Empty);
});
}
/// <summary>
/// Current default from registry is 2.0 if 2.0 is installed
/// </summary>
[Fact]
public void DefaultToolsVersion()
{
if (ToolLocationHelper.GetPathToDotNetFramework(TargetDotNetFrameworkVersion.Version20) == null)
{
// "Requires 2.0 to be installed"
return;
}
using var collection = new ProjectCollection();
Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, collection.DefaultToolsVersion);
}
/// <summary>
/// Current default from registry is 4.0 if 2.0 is not installed
/// </summary>
#if FEATURE_INSTALLED_MSBUILD
[Fact]
#else
[Fact(Skip = "https://github.com/dotnet/msbuild/issues/276")]
#endif
public void DefaultToolsVersion2()
{
if (ToolLocationHelper.GetPathToDotNetFramework(TargetDotNetFrameworkVersion.Version20) != null)
{
// "Requires 2.0 to NOT be installed"
return;
}
using var collection = new ProjectCollection(null, null, ToolsetDefinitionLocations.Registry);
Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, collection.DefaultToolsVersion);
}
/// <summary>
/// Error setting default tools version to empty
/// </summary>
[Fact]
public void SetDefaultToolsVersionEmpty()
{
Assert.Throws<ArgumentException>(() =>
{
ProjectCollection.GlobalProjectCollection.DefaultToolsVersion = String.Empty;
});
}
/// <summary>
/// Error setting default tools version to a toolset that does not exist
/// </summary>
[Fact]
public void SetDefaultToolsVersionNonexistentToolset()
{
Assert.Throws<InvalidOperationException>(() =>
{
ProjectCollection.GlobalProjectCollection.DefaultToolsVersion = "nonexistent";
});
}
/// <summary>
/// Set default tools version; subsequent projects should use it
/// </summary>
[Fact]
public void SetDefaultToolsVersion()
{
using var collection = new ProjectCollection();
collection.AddToolset(new Toolset("x", @"c:\y", collection, null));
collection.DefaultToolsVersion = "x";
Assert.Equal("x", collection.DefaultToolsVersion);
string content = ObjectModelHelpers.CleanupFileContents(@"
<Project xmlns='msbuildnamespace' >
<Target Name='t'/>
</Project>
");
using ProjectFromString projectFromString = new(content, null, null, collection);
Project project = projectFromString.Project;
// ... and after all that, we end up defaulting to the current ToolsVersion instead. There's a way
// to turn this behavior (new in Dev12) off, but it requires setting an environment variable and
// clearing some internal state to make sure that the update environment variable is picked up, so
// there's not a good way of doing it from these deliberately public OM only tests.
Assert.Equal(project.ToolsVersion, ObjectModelHelpers.MSBuildDefaultToolsVersion);
}
/// <summary>
/// Changes to the ProjectCollection object should raise a ProjectCollectionChanged event.
/// </summary>
[Fact]
public void ProjectCollectionChangedEvent()
{
using var collection = new ProjectCollection();
bool dirtyRaised = false;
ProjectCollectionChangedState expectedChange = ProjectCollectionChangedState.Loggers;
collection.ProjectCollectionChanged +=
(sender, e) =>
{
Assert.Same(collection, sender);
Assert.Equal(expectedChange, e.Changed);
dirtyRaised = true;
};
Assert.False(dirtyRaised);
expectedChange = ProjectCollectionChangedState.DisableMarkDirty;
dirtyRaised = false;
collection.DisableMarkDirty = true; // LEAVE THIS TRUE for rest of the test, to verify it doesn't suppress these events
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.IsBuildEnabled;
dirtyRaised = false;
collection.IsBuildEnabled = !collection.IsBuildEnabled;
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.OnlyLogCriticalEvents;
dirtyRaised = false;
collection.OnlyLogCriticalEvents = !collection.OnlyLogCriticalEvents;
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.SkipEvaluation;
dirtyRaised = false;
collection.SkipEvaluation = !collection.SkipEvaluation;
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.GlobalProperties;
dirtyRaised = false;
collection.SetGlobalProperty("a", "b");
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.GlobalProperties;
dirtyRaised = false;
collection.RemoveGlobalProperty("a");
Assert.True(dirtyRaised);
// Verify HostServices changes raise the event.
expectedChange = ProjectCollectionChangedState.HostServices;
dirtyRaised = false;
collection.HostServices = new HostServices();
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.Loggers;
dirtyRaised = false;
collection.RegisterLogger(new MockLogger());
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.Loggers;
dirtyRaised = false;
collection.RegisterLoggers(new Build.Framework.ILogger[] { new MockLogger(), new MockLogger() });
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.Loggers;
dirtyRaised = false;
collection.UnregisterAllLoggers();
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.Toolsets;
dirtyRaised = false;
collection.AddToolset(new Toolset("testTools", Path.GetTempPath(), collection, Path.GetTempPath()));
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.DefaultToolsVersion;
dirtyRaised = false;
collection.DefaultToolsVersion = "testTools";
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.Toolsets;
dirtyRaised = false;
collection.RemoveToolset("testTools");
Assert.True(dirtyRaised);
expectedChange = ProjectCollectionChangedState.Toolsets;
dirtyRaised = false;
collection.RemoveAllToolsets();
Assert.True(dirtyRaised);
}
/// <summary>
/// Changes to the ProjectCollection object should raise a ProjectCollectionChanged event.
/// </summary>
[Fact]
public void ProjectCollectionChangedEvent2()
{
// Verify if the project, project collection and the value we are setting in the project collection are all the same
// then the projects value for the property should not change and no event should be fired.
using var collection = new ProjectCollection();
using XmlReader reader = CreateProjectXmlReader();
Project project = collection.LoadProject(reader, ObjectModelHelpers.MSBuildDefaultToolsVersion);
project.SetProperty("a", "1");
collection.SetGlobalProperty("a", "1");
VerifyProjectCollectionEvents(collection, false, "1");
// Verify if the project, project collection and the value we are setting in the project collection are all the same
// then the projects value for the property should not change and no event should be fired.
using var collection2 = new ProjectCollection();
using var reader2 = CreateProjectXmlReader();
project = collection2.LoadProject(reader2, ObjectModelHelpers.MSBuildDefaultToolsVersion);
project.SetProperty("a", "%28x86%29");
collection2.SetGlobalProperty("a", "%28x86%29");
VerifyProjectCollectionEvents(collection2, false, "%28x86%29");
// Verify if the project, project collection have the same value but a new value is set in the project collection
// then the projects value for the property should be change and an event should be fired.
using var collection3 = new ProjectCollection();
using var reader3 = CreateProjectXmlReader();
project = collection3.LoadProject(reader3, ObjectModelHelpers.MSBuildDefaultToolsVersion);
project.SetProperty("a", "1");
collection3.SetGlobalProperty("a", "1");
VerifyProjectCollectionEvents(collection3, true, "2");
// Verify if the project, project collection have the same value but a new value is set in the project collection
// then the projects value for the property should be change and an event should be fired.
using var collection4 = new ProjectCollection();
using var reader4 = CreateProjectXmlReader();
project = collection4.LoadProject(reader4, ObjectModelHelpers.MSBuildDefaultToolsVersion);
project.SetProperty("a", "1");
collection4.SetGlobalProperty("a", "(x86)");
VerifyProjectCollectionEvents(collection4, true, "%28x86%29");
// Verify if the project has one value and project collection and the property we are setting on the project collection have the same value
// then the projects value for the property should be change but no event should be fired
using var collection5 = new ProjectCollection();
using var reader5 = CreateProjectXmlReader();
project = collection5.LoadProject(reader5, ObjectModelHelpers.MSBuildDefaultToolsVersion);
project.SetProperty("a", "2");
collection5.SetGlobalProperty("a", "1");
VerifyProjectCollectionEvents(collection5, false, "1");
// Verify if the project and the property being set have one value but the project collection has another
// then the projects value for the property should not change and event should be fired
using var collection6 = new ProjectCollection();
using var reader6 = CreateProjectXmlReader();
project = collection6.LoadProject(reader6, ObjectModelHelpers.MSBuildDefaultToolsVersion);
project.SetProperty("a", "1");
collection6.SetGlobalProperty("a", "2");
VerifyProjectCollectionEvents(collection6, true, "1");
// item is added to project collection for the first time. Make sure it is added to the project and an event is fired.
using var collection7 = new ProjectCollection();
using var reader7 = CreateProjectXmlReader();
project = collection7.LoadProject(reader7, ObjectModelHelpers.MSBuildDefaultToolsVersion);
VerifyProjectCollectionEvents(collection7, true, "1");
}
/// <summary>
/// Changes to project XML should raise an ProjectXmlChanged event.
/// </summary>
[Fact]
public void ProjectXmlChangedEvent()
{
using var collection = new ProjectCollection();
ProjectRootElement pre = null;
bool dirtyRaised = false;
collection.ProjectXmlChanged +=
(sender, e) =>
{
Assert.Same(collection, sender);
Assert.Same(pre, e.ProjectXml);
TestOutput.WriteLine(e.Reason ?? String.Empty);
dirtyRaised = true;
};
Assert.False(dirtyRaised);
// Ensure that the event is raised even when DisableMarkDirty is set.
collection.DisableMarkDirty = true;
// Create a new PRE but don't change the template.
dirtyRaised = false;
pre = ProjectRootElement.Create(collection);
Assert.False(dirtyRaised);
// Change PRE prior to setting a filename and thus associating the PRE with the ProjectCollection.
dirtyRaised = false;
pre.AppendChild(pre.CreatePropertyGroupElement());
Assert.False(dirtyRaised);
// Associate with the ProjectCollection
dirtyRaised = false;
pre.FullPath = FileUtilities.GetTemporaryFile();
Assert.True(dirtyRaised);
// Now try dirtying again and see that the event is raised this time.
dirtyRaised = false;
pre.AppendChild(pre.CreatePropertyGroupElement());
Assert.True(dirtyRaised);
// Make sure that project collection global properties don't raise this event.
dirtyRaised = false;
collection.SetGlobalProperty("a", "b");
Assert.False(dirtyRaised);
// Change GlobalProperties on a project to see that doesn't propagate as an XML change.
dirtyRaised = false;
var project = new Project(pre);
project.SetGlobalProperty("q", "s");
Assert.False(dirtyRaised);
// Change XML via the Project to verify the event is raised.
dirtyRaised = false;
project.SetProperty("z", "y");
Assert.True(dirtyRaised);
}
/// <summary>
/// Changes to a Project evaluation object should raise a ProjectChanged event.
/// </summary>
[Fact]
public void ProjectChangedEvent()
{
using var collection = new ProjectCollection();
Project project = null;
bool dirtyRaised = false;
collection.ProjectChanged +=
(sender, e) =>
{
Assert.Same(collection, sender);
Assert.Same(project, e.Project);
dirtyRaised = true;
};
Assert.False(dirtyRaised);
ProjectRootElement pre = ProjectRootElement.Create(collection);
project = new Project(pre, null, null, collection);
// all these should still pass with disableMarkDirty set
collection.DisableMarkDirty = true;
project.DisableMarkDirty = true;
dirtyRaised = false;
pre.AppendChild(pre.CreatePropertyGroupElement());
Assert.False(dirtyRaised); // "Dirtying the XML directly should not result in a ProjectChanged event."
// No events should be raised before we associate a filename with the PRE
dirtyRaised = false;
project.SetGlobalProperty("someGlobal", "someValue");
Assert.False(dirtyRaised);
dirtyRaised = false;
project.SetProperty("someProp", "someValue");
Assert.False(dirtyRaised);
pre.FullPath = FileUtilities.GetTemporaryFile();
dirtyRaised = false;
project.SetGlobalProperty("someGlobal", "someValue2");
Assert.True(dirtyRaised);
dirtyRaised = false;
project.RemoveGlobalProperty("someGlobal");
Assert.True(dirtyRaised);
dirtyRaised = false;
collection.SetGlobalProperty("somePCglobal", "someValue");
Assert.True(dirtyRaised);
dirtyRaised = false;
project.SetProperty("someProp", "someValue2");
Assert.True(dirtyRaised);
}
/// <summary>
/// Verifies that the <see cref="ProjectCollection.Version"/> is correct.
/// </summary>
/// <remarks>
/// This test was written because on OS X and Ubuntu, the version is showing "0.0.0.0"
/// while Windows was working just fine.
/// </remarks>
[Fact]
public void ProjectCollectionVersionIsCorrect()
{
Version expectedVersion = new Version(this.GetType().GetTypeInfo().Assembly.GetCustomAttribute<AssemblyFileVersionAttribute>().Version);
ProjectCollection.Version.Major.ShouldBe(expectedVersion.Major);
ProjectCollection.Version.Minor.ShouldBe(expectedVersion.Minor);
}
/// <summary>
/// Create an empty project file and return the path
/// </summary>
private static string CreateProjectFile()
{
ProjectRootElement xml = ProjectRootElement.Create();
string path = FileUtilities.GetTemporaryFileName();
xml.Save(path);
return path;
}
/// <summary>
/// Create an XmlReader around an empty project file content
/// </summary>
private static XmlReader CreateProjectXmlReader()
{
ProjectRootElement xml = ProjectRootElement.Create();
XmlReader reader = XmlReader.Create(new StringReader(xml.RawXml));
return reader;
}
/// <summary>
/// Verify that when a property is set on the project collection that the correct events are fired.
/// </summary>
private static void VerifyProjectCollectionEvents(ProjectCollection collection, bool expectEventRaised, string propertyValue)
{
bool raisedEvent = false;
ProjectCollectionChangedState expectedChange = ProjectCollectionChangedState.Loggers;
collection.ProjectCollectionChanged +=
(sender, e) =>
{
Assert.Same(collection, sender);
Assert.Equal(expectedChange, e.Changed);
raisedEvent = true;
};
expectedChange = ProjectCollectionChangedState.GlobalProperties;
collection.SetGlobalProperty("a", propertyValue);
Assert.Equal(raisedEvent, expectEventRaised);
ProjectPropertyInstance property = collection.GetGlobalProperty("a");
Assert.NotNull(property);
Assert.Equal(ProjectCollection.Unescape(propertyValue), property.EvaluatedValue);
}
}
}
|