public void CheckReferences(string projectPath, IEnumerable <string> references, string framework)
{
using var projectCollection = new ProjectCollection();
var project = new MSBuildProject(Path.Combine(_projectPath, projectPath),
new Dictionary <string, string>(),
null,
projectCollection);
var targetFrameworksValue = project.GetProperty("TargetFrameworks")?.EvaluatedValue ?? project.GetPropertyValue("TargetFramework");
foreach (var targetFramework in targetFrameworksValue.Split(";", StringSplitOptions.RemoveEmptyEntries).Select(framework => framework.Trim()))
{
project.SetGlobalProperty("TargetFramework", targetFramework);
project.ReevaluateIfNecessary();
var items = project.GetItems("ProjectReference");
var referenceItems = items.Select(item => item.EvaluatedInclude).Select(NormalizePaths);
if (targetFramework == framework)
{
Assert.All(references, reference => Assert.Contains(reference, referenceItems));
Assert.All(references, reference => Assert.Equal("slnmerge", items.FirstOrDefault(item => NormalizePaths(item.EvaluatedInclude) == reference)?.GetMetadataValue("Origin")));
}
else
{
Assert.All(references, reference => Assert.DoesNotContain(reference, referenceItems));
}
}
}
//
// Set Ice Home and force projects to re evaluate changes in the imported project
//
public static void SetIceHome(List <IVsProject> projects, string iceHome, string iceVersion, string iceIntVersion, string iceVersionMM)
{
foreach (IVsProject p in projects)
{
if (DTEUtil.IsIceBuilderEnabled(p) != IceBuilderProjectType.None)
{
Microsoft.Build.Evaluation.Project project = LoadedProject(ProjectUtil.GetProjectFullPath(p), DTEUtil.IsCppProject(p), true);
ResolvedImport import = project.Imports.FirstOrDefault(i => i.ImportedProject.FullPath.EndsWith("IceBuilder.Common.props"));
if (import.ImportedProject != null)
{
ProjectPropertyGroupElement group = import.ImportedProject.PropertyGroups.FirstOrDefault(
g => g.Label.Equals("IceHome", StringComparison.CurrentCultureIgnoreCase));
if (group != null)
{
group.SetProperty(Package.IceHomeValue, iceHome);
group.SetProperty(Package.IceVersionValue, iceVersion);
group.SetProperty(Package.IceIntVersionValue, iceIntVersion);
group.SetProperty(Package.IceVersionMMValue, iceVersionMM);
project.ReevaluateIfNecessary();
}
}
}
}
}
public static void AddImportStatement(this MsBuildProject buildProject, string targetsPath, ProjectImportLocation location)
{
// adds an <Import> element to this project file if it doesn't already exist.
if (buildProject.Xml.Imports == null ||
buildProject.Xml.Imports.All(import => !targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase)))
{
ProjectImportElement pie = buildProject.Xml.AddImport(targetsPath);
pie.Condition = "Exists('" + targetsPath + "')";
if (location == ProjectImportLocation.Top)
{
// There's no public constructor to create a ProjectImportElement directly.
// So we have to cheat by adding Import at the end, then remove it and insert at the beginning
pie.Parent.RemoveChild(pie);
buildProject.Xml.InsertBeforeChild(pie, buildProject.Xml.FirstChild);
}
else
{
// the import might get added into an ImportGroup. In this case,
// we remove it from the ImportGroup and add it at the end of the
// project.
if (pie.Parent.GetType() == typeof(ProjectImportGroupElement))
{
pie.Parent.RemoveChild(pie);
buildProject.Xml.AppendChild(pie);
}
}
NuGet.MSBuildProjectUtility.AddEnsureImportedTarget(buildProject, targetsPath);
buildProject.ReevaluateIfNecessary();
}
}
private async Task ReevaluateLoadedConfiguredProjects(CancellationToken cancellationToken, ProjectWriteLockReleaser access)
{
foreach (var configuredProject in _unconfiguredProject.LoadedConfiguredProjects)
{
try {
MsBuildProject jsproj = await access.GetProjectAsync(configuredProject, cancellationToken);
jsproj.ReevaluateIfNecessary();
} catch (Exception ex) {
Debug.Fail("We were unable to mark a configuration as dirty" + ex.Message, ex.StackTrace);
}
}
}
private static string GetPropertyValueFrom(string projectFile, string propertyName, string solutionDir, string configurationName)
{
using (var projectCollection = new ProjectCollection())
{
var p = new Project(projectFile, null, null, projectCollection, ProjectLoadSettings.Default);
p.SetProperty("Configuration", configurationName);
p.SetProperty("SolutionDir", solutionDir);
p.SetGlobalProperty("SolutionDir", solutionDir);
p.ReevaluateIfNecessary();
return(p.Properties.Where(x => x.Name == propertyName).Select(x => x.EvaluatedValue).SingleOrDefault());
}
}
public static void RemoveImportStatement(this MsBuildProject buildProject, string targetsPath)
{
if (buildProject.Xml.Imports != null)
{
// search for this import statement and remove it
var importElement = buildProject.Xml.Imports.FirstOrDefault(
import => targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase));
if (importElement != null)
{
importElement.Parent.RemoveChild(importElement);
buildProject.ReevaluateIfNecessary();
}
}
}
/// <summary>
/// Removes the Import element from the project file.
/// </summary>
/// <param name="msBuildProject">The project file.</param>
/// <param name="targetsPath">The path to the imported file.</param>
internal static void RemoveImportStatement(MicrosoftBuildEvaluationProject msBuildProject, string targetsPath)
{
if (msBuildProject.Xml.Imports != null)
{
// search for this import statement and remove it
var importElement = msBuildProject.Xml.Imports.FirstOrDefault(
import => targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase));
if (importElement != null)
{
importElement.Parent.RemoveChild(importElement);
RemoveEnsureImportedTarget(msBuildProject, targetsPath);
msBuildProject.ReevaluateIfNecessary();
}
}
}
/// <summary>
/// Removes the Import element from the project file.
/// </summary>
/// <param name="msBuildProject">The project file.</param>
/// <param name="targetsPath">The path to the imported file.</param>
internal static void RemoveImportStatement(MicrosoftBuildEvaluationProject msBuildProject, string targetsPath)
{
if (msBuildProject.Xml.Imports != null)
{
// search for this import statement and remove it
var importElement = msBuildProject.Xml.Imports.FirstOrDefault(
import => targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase));
if (importElement != null)
{
importElement.Parent.RemoveChild(importElement);
RemoveEnsureImportedTarget(msBuildProject, targetsPath);
msBuildProject.ReevaluateIfNecessary();
}
}
}
public bool TryGetOutputDirectory(string configuration, string platform, out DirectoryInfo outputDirectory)
{
_evaluatedProject.SetGlobalProperty("Configuration", configuration);
_evaluatedProject.SetGlobalProperty("Platform", platform);
_evaluatedProject.ReevaluateIfNecessary();
var outputPathProperty = _evaluatedProject.GetProperty("OutputPath");
if (outputPathProperty != null)
{
var absolutePath = Path.Combine(Directory.FullName, outputPathProperty.EvaluatedValue);
outputDirectory = new DirectoryInfo(absolutePath);
return(true);
}
outputDirectory = null;
return(false);
}
public void SpecialCharactersInMetadataValueEvaluation()
{
Microsoft.Build.Evaluation.Project project = new Microsoft.Build.Evaluation.Project();
var metadata = new Dictionary <string, string>
{
{ "EscapedSemicolon", "%3B" }, // Microsoft.Build.Internal.Utilities.Escape(";")
{ "EscapedDollarSign", "%24" }, // Microsoft.Build.Internal.Utilities.Escape("$")
};
Microsoft.Build.Evaluation.ProjectItem item = project.AddItem(
"None",
"MetadataTests",
metadata).Single();
SpecialCharactersInMetadataValueTests(item);
project.ReevaluateIfNecessary();
SpecialCharactersInMetadataValueTests(item);
}
private async Task FileSystemChanged(MsBuildFileSystemWatcher.Changeset changeset)
{
_log.ApplyProjectChangesStarted();
if (_unloadCancellationToken.IsCancellationRequested)
{
return;
}
try {
using (var access = await _projectLockService.WriteLockAsync(_unloadCancellationToken)) {
await access.CheckoutAsync(_inMemoryImportFullPath);
_temporaryAddedItemGroup.RemoveAllChildren();
await RemoveFiles(changeset.RemovedFiles, access);
await RemoveDirectories(changeset.RemovedDirectories, access);
await RenameFiles(changeset.RenamedFiles, access);
await RenameDirectories(changeset.RenamedDirectories, access);
AddDirectories(changeset.AddedDirectories);
AddFiles(changeset.AddedFiles);
_log.MsBuildAfterChangesApplied(_inMemoryImport);
foreach (var configuredProject in _unconfiguredProject.LoadedConfiguredProjects)
{
try {
MsBuildProject project =
await access.GetProjectAsync(configuredProject, _unloadCancellationToken);
project.ReevaluateIfNecessary();
} catch (Exception ex) {
Trace.Fail("Unable to mark a configuration as dirty" + ex.Message, ex.StackTrace);
}
}
}
} catch (Exception ex) {
Trace.Fail("Unable to handle file system change:" + ex.Message, ex.StackTrace);
}
_log.ApplyProjectChangesFinished();
}
internal static void AddImportStatement(MicrosoftBuildEvaluationProject msBuildProject, string targetsPath, ImportLocation location)
{
if (msBuildProject.Xml.Imports == null ||
msBuildProject.Xml.Imports.All(import => !targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase)))
{
ProjectImportElement pie = msBuildProject.Xml.AddImport(targetsPath);
pie.Condition = "Exists('" + targetsPath + "')";
if (location == ImportLocation.Top)
{
// There's no public constructor to create a ProjectImportElement directly.
// So we have to cheat by adding Import at the end, then remove it and insert at the beginning
pie.Parent.RemoveChild(pie);
msBuildProject.Xml.InsertBeforeChild(pie, msBuildProject.Xml.FirstChild);
}
AddEnsureImportedTarget(msBuildProject, targetsPath);
msBuildProject.ReevaluateIfNecessary();
}
}
public static void AddImportStatement(this MsBuildProject buildProject, string targetsPath, ProjectImportLocation location)
{
// adds an <Import> element to this project file if it doesn't already exist.
if (buildProject.Xml.Imports == null ||
buildProject.Xml.Imports.All(import => !targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase)))
{
ProjectImportElement pie = buildProject.Xml.AddImport(targetsPath);
pie.Condition = "Exists('" + targetsPath + "')";
if (location == ProjectImportLocation.Top)
{
// There's no public constructor to create a ProjectImportElement directly.
// So we have to cheat by adding Import at the end, then remove it and insert at the beginning
pie.Parent.RemoveChild(pie);
buildProject.Xml.InsertBeforeChild(pie, buildProject.Xml.FirstChild);
}
buildProject.ReevaluateIfNecessary();
}
}
internal static void AddImportStatement(MicrosoftBuildEvaluationProject msBuildProject, string targetsPath, ImportLocation location)
{
if (msBuildProject.Xml.Imports == null ||
msBuildProject.Xml.Imports.All(import => !targetsPath.Equals(import.Project, StringComparison.OrdinalIgnoreCase)))
{
ProjectImportElement pie = msBuildProject.Xml.AddImport(targetsPath);
pie.Condition = "Exists('" + targetsPath + "')";
if (location == ImportLocation.Top)
{
// There's no public constructor to create a ProjectImportElement directly.
// So we have to cheat by adding Import at the end, then remove it and insert at the beginning
pie.Parent.RemoveChild(pie);
msBuildProject.Xml.InsertBeforeChild(pie, msBuildProject.Xml.FirstChild);
}
AddEnsureImportedTarget(msBuildProject, targetsPath);
msBuildProject.ReevaluateIfNecessary();
}
}
//
// Set Ice Home and force projects to re evaluate changes in the imported project
//
public static void SetIceHome(List <EnvDTE.Project> projects, String iceHome, String iceVersion, String iceIntVersion, String iceVersionMM)
{
foreach (EnvDTE.Project p in projects)
{
Microsoft.Build.Evaluation.Project project = MSBuildUtils.LoadedProject(p.FullName);
ResolvedImport import = project.Imports.FirstOrDefault(i => i.ImportedProject.FullPath.EndsWith("IceBuilder.Common.props"));
if (import.ImportedProject != null)
{
ProjectPropertyGroupElement group = import.ImportedProject.PropertyGroups.FirstOrDefault(g => g.Label.Equals("IceHome"));
if (group != null)
{
group.SetProperty(Package.IceHomeValue, iceHome);
group.SetProperty(Package.IceVersionValue, iceVersion);
group.SetProperty(Package.IceIntVersionValue, iceIntVersion);
group.SetProperty(Package.IceVersionMMValue, iceVersionMM);
project.ReevaluateIfNecessary();
}
}
}
}
public void ExternallyMarkDirty()
{
Project project = new Project();
project.SetProperty("p", "v");
project.ReevaluateIfNecessary();
Assert.Equal(false, project.IsDirty);
ProjectProperty property1 = project.GetProperty("p");
project.MarkDirty();
Assert.Equal(true, project.IsDirty);
project.ReevaluateIfNecessary();
Assert.Equal(false, project.IsDirty);
ProjectProperty property2 = project.GetProperty("p");
Assert.Equal(false, Object.ReferenceEquals(property1, property2)); // different object indicates reevaluation occurred
}
public void ImportedXmlModified()
{
string path = null;
try
{
path = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
ProjectRootElement import = ProjectRootElement.Create(path);
import.Save();
Project project = new Project();
int last = project.EvaluationCounter;
project.Xml.AddImport(path);
project.ReevaluateIfNecessary();
Assert.NotEqual(project.EvaluationCounter, last);
last = project.EvaluationCounter;
project.ReevaluateIfNecessary();
Assert.Equal(project.EvaluationCounter, last);
import.AddProperty("p", "v");
Assert.Equal(true, project.IsDirty);
project.ReevaluateIfNecessary();
Assert.NotEqual(project.EvaluationCounter, last);
last = project.EvaluationCounter;
Assert.Equal("v", project.GetPropertyValue("p"));
project.ReevaluateIfNecessary();
Assert.Equal(project.EvaluationCounter, last);
}
finally
{
File.Delete(path);
}
}
/// <summary>
/// This is used to create a Sandcastle Builder project from an existing MSBuild project instance
/// </summary>
/// <param name="existingProject">The existing project instance</param>
/// <remarks>It is assumed that the project has been loaded, the property values are current, and that
/// the configuration and platform have been set in the MSBuild project global properties in order to
/// get the correct final values.</remarks>
public SandcastleProject(Project existingProject) : this()
{
// Do not remove the project from the MSBuild project collection when this is disposed of since we
// didn't create it.
removeProjectWhenDisposed = false;
msBuildProject = existingProject;
msBuildProject.ReevaluateIfNecessary();
this.UsingFinalValues = true;
this.LoadProperties();
}
public static async Task <Project> CreateAsync(string filepath, Solution parent, IOutputWriter outputWriter)
{
filepath = Path.GetFullPath(filepath, Path.GetDirectoryName(parent.Filepath));
if (!File.Exists(filepath))
{
throw new FileReadException(FileReadExceptionType.Csproj, filepath, parent.Filepath);
}
using var projectCollection = new ProjectCollection();
var msbuildProject = new Microsoft.Build.Evaluation.Project(filepath, new Dictionary <string, string>(), null, projectCollection, ProjectLoadSettings.IgnoreInvalidImports | ProjectLoadSettings.IgnoreMissingImports);
var usingSdk = msbuildProject.Properties.FirstOrDefault(prop => prop.Name == "UsingMicrosoftNETSdk")?.EvaluatedValue.Equals("true", StringComparison.InvariantCultureIgnoreCase) ?? false;
var targetFrameworks = Array.Empty <string>();
if (usingSdk)
{
targetFrameworks = msbuildProject.GetProperty("TargetFrameworks") switch
{
ProjectProperty pp => pp.EvaluatedValue.Split(';', StringSplitOptions.RemoveEmptyEntries).Select(val => val.Trim()).ToArray(),
null => new[] { msbuildProject.GetPropertyValue("TargetFramework") }
};
}
else
{
targetFrameworks = new[] {
msbuildProject.GetPropertyValue("TargetFrameworkVersion")
.Replace("v", "net")
.Replace(".", "")
};
}
var packageReferences = new Dictionary <string, Reference>();
var projectReferences = new Dictionary <string, Reference>();
foreach (var targetFramework in targetFrameworks)
{
msbuildProject.SetGlobalProperty("TargetFramework", targetFramework);
msbuildProject.ReevaluateIfNecessary();
foreach (var include in GetItems(msbuildProject, "PackageReference"))
{
if (!packageReferences.TryGetValue(include, out var reference))
{
reference = new Reference
{
Include = include
};
packageReferences.Add(include, reference);
}
reference.Frameworks.Add(targetFramework);
}
foreach (var item in msbuildProject.GetItems("ProjectReference"))
{
var include = ConvertPathSeparators(item.EvaluatedInclude);
if (!projectReferences.TryGetValue(include, out var reference))
{
reference = new Reference
{
Include = include,
Origin = item.GetMetadataValue("Origin")
};
projectReferences.Add(include, reference);
}
reference.Frameworks.Add(targetFramework);
}
}
var packageId = await GetPackageId(filepath, msbuildProject);
return(new Project(filepath, packageId, packageReferences.Values.ToList(), projectReferences.Values.ToList(), targetFrameworks, outputWriter, parent, !usingSdk));
}
public void DoubleImportIndirectIgnored()
{
string file = null;
string file2 = null;
string file3 = null;
try
{
ProjectCollection collection = new ProjectCollection();
MockLogger logger = new MockLogger();
collection.RegisterLogger(logger);
file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
file2 = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
file3 = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
Project project = new Project(collection);
project.Xml.AddImport(file2);
project.Xml.AddImport(file3);
project.Save(file);
Project project2 = new Project(collection);
project.Xml.AddImport(file3);
project2.Save(file2);
Project project3 = new Project(collection);
project3.Save(file3);
project.ReevaluateIfNecessary();
logger.AssertLogContains("MSB4011"); // duplicate import
}
finally
{
File.Delete(file);
File.Delete(file2);
File.Delete(file3);
}
}
public void ItemsByEvaluatedIncludeReevaluation()
{
Project project = new Project();
project.Xml.AddItem("i", "i1");
project.ReevaluateIfNecessary();
List<ProjectItem> items = Helpers.MakeList(project.GetItemsByEvaluatedInclude("i1"));
Assert.Equal(1, items.Count);
project.Xml.AddItem("j", "i1");
project.ReevaluateIfNecessary();
items = Helpers.MakeList(project.GetItemsByEvaluatedInclude("i1"));
Assert.Equal(2, items.Count);
}
public void ChangeEnvironmentProperty()
{
Project project = new Project();
project.SetProperty("computername", "v1");
Assert.Equal("v1", project.GetPropertyValue("computername"));
Assert.Equal(true, project.IsDirty);
project.ReevaluateIfNecessary();
Assert.Equal("v1", project.GetPropertyValue("computername"));
}
public void SkipEvaluation()
{
Project project = new Project();
project.SetGlobalProperty("p", "v1");
project.ReevaluateIfNecessary();
Assert.Equal("v1", project.GetPropertyValue("p"));
project.SkipEvaluation = true;
ProjectPropertyElement propertyElement = project.Xml.AddProperty("p1", "v0");
propertyElement.Condition = "'$(g)'=='v1'";
project.SetGlobalProperty("g", "v1");
project.ReevaluateIfNecessary();
Assert.Equal(String.Empty, project.GetPropertyValue("p1"));
project.SkipEvaluation = false;
project.SetGlobalProperty("g", "v1");
project.ReevaluateIfNecessary();
Assert.Equal("v0", project.GetPropertyValue("p1"));
}
public void ChangeGlobalProperties()
{
Project project = new Project();
ProjectPropertyElement propertyElement = project.Xml.AddProperty("p", "v0");
propertyElement.Condition = "'$(g)'=='v1'";
project.ReevaluateIfNecessary();
Assert.Equal(String.Empty, project.GetPropertyValue("p"));
Assert.Equal(true, project.SetGlobalProperty("g", "v1"));
Assert.Equal(true, project.IsDirty);
project.ReevaluateIfNecessary();
Assert.Equal("v0", project.GetPropertyValue("p"));
Assert.Equal("v1", project.GlobalProperties["g"]);
}
public void ItemsByEvaluatedInclude()
{
Project project = new Project();
project.Xml.AddItem("i", "i1");
project.Xml.AddItem("i", "i1");
project.Xml.AddItem("j", "j1");
project.Xml.AddItem("j", "i1");
project.ReevaluateIfNecessary();
List<ProjectItem> items = Helpers.MakeList(project.GetItemsByEvaluatedInclude("i1"));
Assert.Equal(3, items.Count);
foreach (ProjectItem item in items)
{
Assert.Equal("i1", item.EvaluatedInclude);
}
}
public void ItemsByEvaluatedInclude_EvaluatedIncludeNeedsEscaping()
{
Project project = new Project();
project.Xml.AddItem("i", "i%261");
project.Xml.AddItem("j", "i%25261");
project.Xml.AddItem("k", "j1");
project.Xml.AddItem("l", "i&1");
project.ReevaluateIfNecessary();
List<ProjectItem> items = Helpers.MakeList(project.GetItemsByEvaluatedInclude("i&1"));
Assert.Equal(2, items.Count);
foreach (ProjectItem item in items)
{
Assert.Equal("i&1", item.EvaluatedInclude);
Assert.True(
String.Equals(item.ItemType, "i", StringComparison.OrdinalIgnoreCase) ||
String.Equals(item.ItemType, "l", StringComparison.OrdinalIgnoreCase)
);
}
}
public void ChangeGlobalPropertiesInitiallyFromProjectCollection()
{
Dictionary<string, string> initial = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
initial.Add("p0", "v0");
initial.Add("p1", "v1");
ProjectCollection collection = new ProjectCollection(initial, null, ToolsetDefinitionLocations.ConfigurationFile);
Project project = new Project(collection);
ProjectPropertyElement propertyElement = project.Xml.AddProperty("pp", "vv");
propertyElement.Condition = "'$(p0)'=='v0' and '$(p1)'=='v1b'";
project.ReevaluateIfNecessary();
Assert.Equal(String.Empty, project.GetPropertyValue("pp"));
project.SetGlobalProperty("p1", "v1b");
Assert.Equal(true, project.IsDirty);
project.ReevaluateIfNecessary();
Assert.Equal("vv", project.GetPropertyValue("pp"));
Assert.Equal("v0", collection.GlobalProperties["p0"]);
Assert.Equal("v1", collection.GlobalProperties["p1"]);
}
public void ImportSelfIgnored()
{
string file = null;
try
{
ProjectCollection collection = new ProjectCollection();
MockLogger logger = new MockLogger();
collection.RegisterLogger(logger);
Project project = new Project(collection);
project.Xml.AddImport("$(MSBuildProjectFullPath)");
file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
project.Save(file);
project.ReevaluateIfNecessary();
logger.AssertLogContains("MSB4210"); // selfimport
}
finally
{
File.Delete(file);
}
}
public void RemoveGlobalProperties()
{
Project project = new Project();
ProjectPropertyElement propertyElement = project.Xml.AddProperty("p", "v0");
propertyElement.Condition = "'$(g)'==''";
project.SetGlobalProperty("g", "v1");
project.ReevaluateIfNecessary();
Assert.Equal(String.Empty, project.GetPropertyValue("p"));
bool existed = project.RemoveGlobalProperty("g");
Assert.Equal(true, existed);
Assert.Equal(true, project.IsDirty);
project.ReevaluateIfNecessary();
Assert.Equal("v0", project.GetPropertyValue("p"));
Assert.Equal(false, project.GlobalProperties.ContainsKey("g"));
}
public void TransformsUseCorrectDirectory_Basic()
{
string file = null;
string projectFileContent = ObjectModelHelpers.CleanupFileContents(@"
<Project xmlns='msbuildnamespace'>
<ItemGroup>
<IntermediateAssembly Include='obj\i386\foo.dll'/>
<BuiltProjectOutputGroupKeyOutput Include=""@(IntermediateAssembly->'%(FullPath)')""/>
</ItemGroup>
</Project>");
ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(projectFileContent)));
Project project = new Project(xml);
try
{
file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
project.Save(file);
project.ReevaluateIfNecessary();
Assert.Equal(Path.Combine(Path.GetTempPath(), @"obj\i386\foo.dll"), project.GetItems("BuiltProjectOutputGroupKeyOutput").First().EvaluatedInclude);
}
finally
{
File.Delete(file);
}
}
public void SettingItemExcludeDirties()
{
Project project = new Project();
ProjectItem item = project.AddItem("i", "i1")[0];
project.ReevaluateIfNecessary();
item.Xml.Exclude = "i1";
project.ReevaluateIfNecessary();
Assert.Equal(0, Helpers.MakeList(project.Items).Count);
}
public void ChangeGlobalPropertyAfterReevaluation()
{
Project project = new Project();
project.SetGlobalProperty("p", "v1");
project.ReevaluateIfNecessary();
project.SetGlobalProperty("p", "v2");
Assert.Equal("v2", project.GetPropertyValue("p"));
Assert.Equal(true, project.GetProperty("p").IsGlobalProperty);
}
/// <summary>
/// Sets the value of the property.
/// </summary>
/// <param name="value">Property value to set.</param>
/// <param name="configs">Optional list of configurations to set the property in;
/// defaults to the project current configuration</param>
/// <remarks>
/// Before calling this method, the caller must ensure that the value is valid according to
/// the <see cref="PropertyValidator"/> class, and that the project file is writable.
/// In most cases the caller should also ensure that the new value is different from the
/// existing value, to avoid dirtying the project file unnecessarily.
/// </remarks>
public void SetValue(string value, IList <ProjectConfig> configs)
{
WixHelperMethods.VerifyNonNullArgument(value, "value");
value = value.Trim();
MSBuild.Project buildProject = this.project.BuildProject;
if (this.PerUser)
{
if (this.project.UserBuildProject == null)
{
this.project.CreateUserBuildProject();
}
buildProject = this.project.UserBuildProject;
}
value = this.Escape(value);
if (this.PerConfig)
{
if (configs == null || configs.Count == 0)
{
configs = new ProjectConfig[] { this.project.CurrentConfig };
}
foreach (ProjectConfig config in configs)
{
bool set = false;
// First see if there's an existing property group that matches our condition
foreach (ProjectPropertyGroupElement propGroup in buildProject.Xml.PropertyGroups)
{
// if there is, set it within that group
if (String.Equals(propGroup.Condition, config.Condition, StringComparison.Ordinal))
{
propGroup.SetProperty(this.propertyName, value);
set = true;
break;
}
}
// If not, add a new property group for the condition and set the property within it
if (!set)
{
ProjectPropertyGroupElement newPropGroup = buildProject.Xml.AddPropertyGroup();
newPropGroup.Condition = config.Condition;
newPropGroup.SetProperty(this.propertyName, value);
set = true;
}
buildProject.ReevaluateIfNecessary();
}
}
else
{
if (this.EndOfProjectFile)
{
List <ProjectPropertyGroupElement> propertyGroupsToDelete = new List <ProjectPropertyGroupElement>();
// First see if there's an existing property group with our property
foreach (ProjectPropertyGroupElement propGroup in buildProject.Xml.PropertyGroups)
{
List <ProjectPropertyElement> propertiesToDelete = new List <ProjectPropertyElement>();
if (!String.IsNullOrEmpty(propGroup.Condition))
{
continue;
}
foreach (ProjectPropertyElement property in propGroup.Properties)
{
// if there is, remove it so the new value is at the end of the file
if (String.IsNullOrEmpty(property.Condition) && String.Equals(property.Name, this.propertyName, StringComparison.OrdinalIgnoreCase))
{
propertiesToDelete.Add(property);
}
}
foreach (ProjectPropertyElement property in propertiesToDelete)
{
propGroup.RemoveChild(property);
}
if (propGroup.Count == 0)
{
propertyGroupsToDelete.Add(propGroup);
}
}
foreach (ProjectPropertyGroupElement propGroup in propertyGroupsToDelete)
{
buildProject.Xml.RemoveChild(propGroup);
}
ProjectPropertyGroupElement newPropGroup = buildProject.Xml.CreatePropertyGroupElement();
buildProject.Xml.AppendChild(newPropGroup);
newPropGroup.SetProperty(this.propertyName, value);
}
else
{
buildProject.SetProperty(this.propertyName, value);
}
}
this.project.InvalidatePropertyCache();
this.project.SetProjectFileDirty(true);
}
public void ChangeGlobalPropertyAfterReevaluation2()
{
Assert.Throws<InvalidOperationException>(() =>
{
Project project = new Project();
project.SetGlobalProperty("p", "v1");
project.ReevaluateIfNecessary();
project.SetProperty("p", "v2");
}
);
}
public void SetUnchangedValue()
{
Project project = new Project();
ProjectItem item = project.AddItem("i", "i1")[0];
item.SetMetadataValue("m", "m1");
project.ReevaluateIfNecessary();
item.SetMetadataValue("m", "m1");
Assert.AreEqual(false, project.IsDirty);
item.GetMetadata("m").UnevaluatedValue = "m1";
Assert.AreEqual(false, project.IsDirty);
}
public void ChangeGlobalPropertiesPreexisting()
{
Dictionary<string, string> initial = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
initial.Add("p0", "v0");
initial.Add("p1", "v1");
Project project = new Project(ProjectRootElement.Create(), initial, null);
ProjectPropertyElement propertyElement = project.Xml.AddProperty("pp", "vv");
propertyElement.Condition = "'$(p0)'=='v0' and '$(p1)'=='v1b'";
project.ReevaluateIfNecessary();
Assert.Equal(String.Empty, project.GetPropertyValue("pp"));
project.SetGlobalProperty("p1", "v1b");
Assert.Equal(true, project.IsDirty);
project.ReevaluateIfNecessary();
Assert.Equal("vv", project.GetPropertyValue("pp"));
Assert.Equal("v0", project.GlobalProperties["p0"]);
Assert.Equal("v1b", project.GlobalProperties["p1"]);
}
public void Dirtying_ItemCondition()
{
XmlReader content = XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<ItemGroup>
<i Include=""i1"" />
</ItemGroup>
</Project>")));
Project project = new Project(content);
ProjectItem item = Helpers.GetFirst(project.Items);
item.Xml.Condition = "false";
Assert.Equal(1, Helpers.Count(project.Items));
project.ReevaluateIfNecessary();
Assert.Equal(0, Helpers.Count(project.Items));
}
public void ChangeGlobalPropertiesSameValue()
{
Project project = new Project();
project.SetGlobalProperty("g", "v1");
Assert.Equal(true, project.IsDirty);
project.ReevaluateIfNecessary();
Assert.Equal(false, project.SetGlobalProperty("g", "v1"));
Assert.Equal(false, project.IsDirty);
}
public void Dirtying_MetadataCondition()
{
XmlReader content = XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<ItemGroup>
<i Include=""i1"">
<m>m1</m>
</i>
</ItemGroup>
</Project>")));
Project project = new Project(content);
ProjectMetadata metadatum = Helpers.GetFirst(project.Items).GetMetadata("m");
metadatum.Xml.Condition = "false";
Assert.Equal("m1", metadatum.EvaluatedValue);
project.ReevaluateIfNecessary();
metadatum = Helpers.GetFirst(project.Items).GetMetadata("m");
Assert.Equal(null, metadatum);
}
public void SettingItemIncludeDirties()
{
Project project = new Project();
ProjectItem item = project.AddItem("i", "i1")[0];
project.ReevaluateIfNecessary();
item.Xml.Include = "i2";
project.ReevaluateIfNecessary();
Assert.Equal("i2", Helpers.GetFirst(project.Items).EvaluatedInclude);
}
public void ProjectToolsVersion20NotPresent()
{
if (ToolLocationHelper.GetPathToDotNetFramework(TargetDotNetFrameworkVersion.Version20) != null)
{
// "Requires 2.0 to NOT be installed"
return;
}
Project project = new Project();
project.Xml.ToolsVersion = "2.0";
project.ReevaluateIfNecessary();
Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, project.ToolsVersion);
project.Xml.ToolsVersion = ObjectModelHelpers.MSBuildDefaultToolsVersion;
Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, project.ToolsVersion);
}
public void SpecialCharactersInMetadataValueEvaluation()
{
Project project = new Project();
ProjectItem item = project.AddItem("None", "MetadataTests", new Dictionary<string, string> {
{"EscapedSemicolon", "%3B"}, //Microsoft.Build.Evaluation.ProjectCollection.Escape(";")
{"EscapedDollarSign", "%24"}, //Microsoft.Build.Evaluation.ProjectCollection.Escape("$")
}).Single();
EscapingInProjectsHelper.SpecialCharactersInMetadataValueTests(item);
project.ReevaluateIfNecessary();
EscapingInProjectsHelper.SpecialCharactersInMetadataValueTests(item);
}
public void MSBuildToolsVersionProperty()
{
if (ToolLocationHelper.GetPathToDotNetFramework(TargetDotNetFrameworkVersion.Version20) == null)
{
// "Requires 2.0 to be installed"
return;
}
Project project = new Project();
project.Xml.ToolsVersion = "2.0";
project.ReevaluateIfNecessary();
// ... 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(ObjectModelHelpers.MSBuildDefaultToolsVersion, project.GetPropertyValue("msbuildtoolsversion"));
project.Xml.ToolsVersion = "4.0";
// Still current
Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, project.GetPropertyValue("msbuildtoolsversion"));
project.ReevaluateIfNecessary();
// Still current
Assert.Equal(ObjectModelHelpers.MSBuildDefaultToolsVersion, project.GetPropertyValue("msbuildtoolsversion"));
}
public void TestRunPythonCommand() {
var expectedSearchPath = string.Format("['{0}', '{1}']",
TestData.GetPath(@"TestData").Replace("\\", "\\\\"),
TestData.GetPath(@"TestData\HelloWorld").Replace("\\", "\\\\")
);
var proj = new Project(TestData.GetPath(@"TestData\Targets\Commands4.pyproj"));
foreach (var version in PythonPaths.Versions) {
var verStr = version.Version.ToVersion().ToString();
proj.SetProperty("InterpreterId", version.Id.ToString("B"));
proj.SetProperty("InterpreterVersion", verStr);
proj.RemoveItems(proj.ItemsIgnoringCondition.Where(i => i.ItemType == "InterpreterReference").ToArray());
proj.AddItem("InterpreterReference", string.Format("{0:B}\\{1}", version.Id, verStr));
proj.Save();
proj.ReevaluateIfNecessary();
var log = new StringLogger(LoggerVerbosity.Minimal);
Assert.IsTrue(proj.Build("CheckCode", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed), log }));
Console.WriteLine();
Console.WriteLine("Output from {0:B} {1}", version.Id, version.Version.ToVersion());
foreach (var line in log.Lines) {
Console.WriteLine("* {0}", line.TrimEnd('\r', '\n'));
}
var logLines = log.Lines.Last().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual(2, logLines.Length);
Assert.AreEqual(version.Version.ToVersion().ToString(), logLines[0].Trim());
Assert.AreEqual(expectedSearchPath, logLines[1].Trim());
}
}
public void ReevaluationCounter()
{
Project project = new Project();
int last = project.EvaluationCounter;
project.ReevaluateIfNecessary();
Assert.Equal(project.EvaluationCounter, last);
last = project.EvaluationCounter;
project.SetProperty("p", "v");
project.ReevaluateIfNecessary();
Assert.NotEqual(project.EvaluationCounter, last);
}
