public void ImportFromExtensionsPathNotFound()
{
string extnDir1 = null;
string mainProjectPath = null;
try {
extnDir1 = GetNewExtensionsPathAndCreateFile("extensions1", Path.Combine("foo", "extn.proj"), GetExtensionTargetsFileContent1());
mainProjectPath = ObjectModelHelpers.CreateFileInTempProjectDirectory("main.proj", GetMainTargetFileContent());
var projColln = new ProjectCollection();
projColln.ResetToolsetsForTests(WriteConfigFileAndGetReader("MSBuildExtensionsPath", extnDir1, Path.Combine("tmp", "nonexistant")));
var logger = new MockLogger();
projColln.RegisterLogger(logger);
Assert.Throws<InvalidProjectFileException>(() => projColln.LoadProject(mainProjectPath));
logger.AssertLogContains("MSB4226");
} finally {
if (mainProjectPath != null)
{
FileUtilities.DeleteNoThrow(mainProjectPath);
}
if (extnDir1 != null)
{
FileUtilities.DeleteDirectoryNoThrow(extnDir1, recursive: true);
}
}
}
public void TargetARM()
{
string file = null;
string outputPath = Path.GetTempPath() + "\\" + Guid.NewGuid().ToString("N");
try
{
file = Helpers.CreateFiles("class1.cs")[0];
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.CreateInMemoryProject(
@"
<Project DefaultTargets=`Build` ToolsVersion=`4.0` xmlns=`msbuildnamespace`>
<PropertyGroup>
<OutputPath>" + outputPath + @"</OutputPath>
<AssemblyName>MyAssembly</AssemblyName>
<OutputType>Library</OutputType>
<Configuration>Debug</Configuration>
<PlatformTarget>arm</PlatformTarget>
</PropertyGroup>
<ItemGroup>
<Compile Include=`" + file + @"` />
</ItemGroup>
<Import Project=`$(MSBuildToolsPath)\Microsoft.CSharp.Targets` />
</Project>
",
logger
);
project.Build();
logger.AssertLogContains(" /platform:arm ");
}
finally
{
if (file != null)
{
File.Delete(file);
}
ObjectModelHelpers.DeleteDirectory(outputPath);
}
}
/// <summary>
/// Assert that the log file contains the given string.
/// Case insensitive.
/// First check if the string is in the log string. If not
/// than make sure it is also check the MockLogger
/// </summary>
internal void AssertLogContains(string contains)
{
// If we do not contain this string than pass it to
// MockLogger. Since MockLogger is also registered as
// a logger it may have this string.
var logText = _log.ToString();
if (logText.IndexOf(contains, StringComparison.OrdinalIgnoreCase) == -1)
{
if (_output == null)
{
Console.WriteLine(logText);
}
else
{
_output.WriteLine(logText);
}
_mockLogger.AssertLogContains(contains);
}
}
public void Simple()
{
MockLogger log = ObjectModelHelpers.BuildProjectExpectSuccess(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<AToB Include=`a;b`/>
</ItemGroup>
<Target Name=`Build`>
<CreateItem Include=`%(AToB.Identity)`>
<Output ItemName=`AToBBatched` TaskParameter=`Include`/>
</CreateItem>
<Message Text=`[AToBBatched: @(AToBBatched)]`/>
</Target>
</Project>
");
log.AssertLogContains("[AToBBatched: a;b]");
}
public void CreateBlankProperty()
{
MockLogger logger = ObjectModelHelpers.BuildProjectExpectSuccess(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<PropertyGroup>
<NumberOfProcessors>Twenty</NumberOfProcessors>
</PropertyGroup>
<Target Name=`Build`>
<CreateProperty Value=``>
<Output PropertyName=`NumberOfProcessors` TaskParameter=`Value`/>
</CreateProperty>
<Message Text=`NumberOfProcessors='$(NumberOfProcessors)'`/>
</Target>
</Project>
");
logger.AssertLogContains("NumberOfProcessors=''");
}
/// <summary>
/// Assert that the log file contains the given string.
/// Case insensitive.
/// First check if the string is in the log string. If not
/// than make sure it is also check the MockLogger
/// </summary>
/// <param name="contains"></param>
internal void AssertLogContains(string contains)
{
if (_upperLog == null)
{
_upperLog = _log;
_upperLog = _upperLog.ToUpperInvariant();
}
// If we do not contain this string than pass it to
// MockLogger. Since MockLogger is also registered as
// a logger it may have this string.
if (!_upperLog.Contains
(
contains.ToUpperInvariant()
)
)
{
Console.WriteLine(_log);
_mockLogger.AssertLogContains(contains);
}
}
public void OnErrorSeesPropertiesAndItemsFromFirstTarget()
{
MockLogger l = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name='Build'>
<!-- Create a bunch of items and properties -->
<CreateItem Include='a1'>
<Output ItemName='i1' TaskParameter='Include'/>
</CreateItem>
<ItemGroup>
<i1 Include='a2'/>
</ItemGroup>
<CreateProperty Value='v1'>
<Output PropertyName='p1' TaskParameter='Value'/>
</CreateProperty>
<PropertyGroup>
<p2>v2</p2>
</PropertyGroup>
<Error Text='This is an error.'/>
<OnError ExecuteTargets='ErrorTarget'/>
</Target>
<Target Name='ErrorTarget'>
<Message Text='[@(i1)][$(p1)][$(p2)]'/>
</Target>
</Project>",
l
);
p.Build(new string[] { "Build" }, null);
Assertion.Assert("Expected one error because 'Build' failed.", l.ErrorCount == 1);
l.AssertLogContains("[a1;a2][v1][v2]");
}
public void SetInputsOutputsIncremental()
{
string oldFile = null, newFile = null;
try
{
oldFile = GetTempFiles(1, new DateTime(2005, 1, 1))[0];
newFile = GetTempFiles(1, new DateTime(2006, 1, 1))[0];
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`t` Inputs=`" + newFile + "` Outputs=`" + oldFile + @"`>
<Message Text=`building target !!`/>
</Target>
</Project>
", logger);
p.Build(new string[] { "t" });
logger.AssertLogContains(new string[] { "building target !!" });
logger.ClearLog();
Target t = p.Targets["t"];
// reverse inputs and outputs
t.Inputs = (string)oldFile;
t.Outputs = (string)newFile;
p.ResetBuildStatus();
p.Build(new string[] { "t" });
logger.AssertLogDoesntContain("building target !!");
}
finally
{
DeleteTempFiles(new string[] { oldFile });
DeleteTempFiles(new string[] { newFile });
}
}
public void ItemsPickUpItemDefinitionMetadataFromImportedProject()
{
try
{
ObjectModelHelpers.CreateFileInTempProjectDirectory("foo.proj", @"
<Project DefaultTargets=`t` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<ItemWithDefinition Include=`foo.cs` />
</ItemGroup>
<Target Name=`t`>
<Message Text=`[%(ItemWithDefinition.SomeMetadata)]` />
</Target>
<Import Project=`foo2.proj` />
</Project>
");
ObjectModelHelpers.CreateFileInTempProjectDirectory("foo2.proj", @"
<Project DefaultTargets=`t2` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemDefinitionGroup>
<ItemWithDefinition>
<SomeMetadata>foo</SomeMetadata>
</ItemWithDefinition>
</ItemDefinitionGroup>
<Target Name=`t2` />
</Project>
");
MockLogger logger = ObjectModelHelpers.BuildTempProjectFileExpectSuccess("foo.proj");
logger.AssertLogContains("[foo]");
}
finally
{
ObjectModelHelpers.DeleteTempProjectDirectory();
}
}
public void ItemsPickUpItemDefinitionMetadata()
{
MockLogger logger = ObjectModelHelpers.BuildProjectExpectSuccess(@"
<Project DefaultTargets=`t` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemDefinitionGroup>
<ItemWithDefinition>
<SomeMetadata>foo</SomeMetadata>
</ItemWithDefinition>
</ItemDefinitionGroup>
<ItemGroup>
<ItemWithDefinition Include=`foo.cs` />
</ItemGroup>
<Target Name=`t`>
<Message Text=`[%(ItemWithDefinition.SomeMetadata)]` />
</Target>
</Project>
");
logger.AssertLogContains("[foo]");
}
public void TestPathFixupInMetadata()
{
string buildProjectContents = @"
<Project>
<Target Name='Build'>
<MSBuild Projects='projectDirectory/main.proj' />
</Target>
</Project>";
string mainProjectContents = @"
<Project>
<UsingTask TaskName='LogTaskPropertiesTask' AssemblyName='Microsoft.Build.Engine.UnitTests' />
<ItemGroup>
<Item0 Include='xyz'>
<Md0>lib\foo.dll</Md0>
</Item0>
</ItemGroup>
<Target Name='Build'>
<LogTaskPropertiesTask Items='@(Item0)' />
</Target>
</Project>";
string buildProjectPath = ObjectModelHelpers.CreateFileInTempProjectDirectory("build.proj", buildProjectContents);
ObjectModelHelpers.CreateFileInTempProjectDirectory("projectDirectory/main.proj", mainProjectContents);
ObjectModelHelpers.CreateFileInTempProjectDirectory(Path.Combine("projectDirectory", "lib", "foo.dll"), "just a text file");
var projColln = new ProjectCollection();
var logger = new MockLogger();
projColln.RegisterLogger(logger);
var project = projColln.LoadProject(buildProjectPath);
var result = project.Build("Build");
Assert.True(result);
logger.AssertLogContains($"ItemMetadata: Md0 = {Path.Combine("lib", "foo.dll")}");
}
public void CaptureTargetOutputsRunningEachTargetSeparately()
{
MockLogger logger = ObjectModelHelpers.BuildProjectExpectSuccess(@"
<Project DefaultTargets = `CallT` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name = `a` Outputs = `a.txt`/>
<Target Name = `b` Outputs = `b.txt`/>
<Target Name = `c` Outputs = `c.txt`/>
<Target Name = `CallT`>
<CallTarget
Targets = `a;b;c`
RunEachTargetSeparately = `true`>
<Output TaskParameter= `TargetOutputs` ItemName = `TaskOut`/>
</CallTarget>
<Message Text = `CallTarget Outputs: @(TaskOut)`/>
</Target>
</Project>
");
// All three targets should have been run.
logger.AssertLogContains("CallTarget Outputs: a.txt;b.txt;c.txt");
}
public void MutualReferenceToMetadataQualified()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include=`i1`>
<m>m1</m>
<m>%(i.m);m2</m>
<m Condition='false'>%(m);m3</m>
</i>
</ItemGroup>
<Target Name=`t`>
<Message Text=`[%(i.m)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[m1;m2]");
}
public void ItemDefinitionForOtherItemType()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
<ItemDefinitionGroup>
<j>
<m>m1</m>
</j>
</ItemDefinitionGroup>
<Target Name=`t`>
<Message Text=`[%(i.m)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[]");
}
public void EscapingInItemDefinitionInProject()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
<ItemDefinitionGroup Condition=`'%24'=='$'`>
<i Condition=`'%24'=='$'`>
<m Condition=`'%24'=='$'`>%24(xyz)</m>
</i>
</ItemDefinitionGroup>
<Target Name=`t`>
<Message Text=`[%(i.m)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[$(xyz)]");
}
public void SetGlobalPropertyAfterLoadBeforeBuild()
{
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`log_property`>
<Message Text=`[$(p)]`/>
</Target>
</Project>
", logger);
BuildPropertyGroup globals = project.GlobalProperties;
// Set a property before building -- this should work
BuildProperty p = new BuildProperty("p", "v1");
globals.SetProperty(p);
project.Build();
logger.AssertLogContains("[v1]");
}
public void EscapeOutputItemspecs()
{
string projectContents = @"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`t` >
<CreateItem Include=`%2520`><!-- should be a literal %20 not a space -->
<Output TaskParameter=`Include` ItemName=`Include`/>
</CreateItem>
<Message Text=`@(include)` Importance=`high`/>
</Target>
</Project>
";
Project p = ObjectModelHelpers.CreateInMemoryProject(projectContents);
MockLogger l = new MockLogger();
p.ParentEngine.RegisterLogger(l);
p.Build(new string[] { "t" }, null);
Assertion.Assert(l.ErrorCount == 0);
Assertion.Assert(l.WarningCount == 0);
l.AssertLogContains("%20");
}
public void MetadataConditionOnItemDefinition()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include='i1'/>
<j Include='j1'/>
</ItemGroup>
<ItemDefinitionGroup>
<i>
<m>m1</m>
</i>
<j>
<n>n1</n>
</j>
</ItemDefinitionGroup>
<ItemDefinitionGroup>
<i Condition=`'%(m)'=='m1'`>
<m>m2</m>
</i>
<!-- verify j metadata is distinct -->
<j Condition=`'%(j.n)'=='n1' and '%(n)'=='n1'`>
<n>n2</n>
</j>
</ItemDefinitionGroup>
<Target Name=`t`>
<Message Text=`[%(i.m)]`/>
<Message Text=`[%(j.n)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[m2]", "[n2]");
}
public void DefinitionInImportedFile()
{
MockLogger logger = new MockLogger();
string importedFile = null;
try
{
importedFile = Path.GetTempFileName();
File.WriteAllText(importedFile, @"
<Project ToolsVersion='3.5' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<ItemDefinitionGroup>
<CppCompile>
<Defines>DEBUG</Defines>
</CppCompile>
</ItemDefinitionGroup>
</Project>
");
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<CppCompile Include='a.cpp'/>
</ItemGroup>
<Import Project='" + importedFile + @"'/>
<Target Name=`t`>
<Message Text=`[%(CppCompile.Identity)==%(CppCompile.Defines)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[a.cpp==DEBUG]");
}
finally
{
ObjectModelHelpers.DeleteTempFiles(new string[] { importedFile });
}
}
public void MutualReferenceToDefinition2()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemDefinitionGroup>
<i>
<m>~%(n)~</m>
<n>n1</n>
</i>
</ItemDefinitionGroup>
<ItemGroup>
<i Include=`i1`/>
</ItemGroup>
<Target Name=`t`>
<Message Text=`[%(i.m)][%(i.n)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[~~][n1]");
}
public void ItemsEmittedByTaskPickUpItemDefinitions()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemDefinitionGroup>
<i>
<m>m1</m>
<n>n1</n>
</i>
</ItemDefinitionGroup>
<Target Name=`t`>
<CreateItem Include=`i1` AdditionalMetadata=`n=n2`>
<Output ItemName=`i` TaskParameter=`Include`/>
</CreateItem>
<Message Text=`[%(i.m)][%(i.n)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[m1][n2]");
}
public void SetGlobalPropertyAfterLoadBeforeBuild()
{
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`log_property`>
<Message Text=`[$(p)]`/>
</Target>
</Project>
", logger);
BuildPropertyGroup globals = project.GlobalProperties;
// Set a property before building -- this should work
BuildProperty p = new BuildProperty("p", "v1");
globals.SetProperty(p);
project.Build();
logger.AssertLogContains("[v1]");
}
public void TestSkipInvalidConfigurationsCase()
{
string tmpFileName = Path.GetTempFileName();
File.Delete(tmpFileName);
string projectFilePath = tmpFileName + ".sln";
string solutionContents =
@"
Microsoft Visual Studio Solution File, Format Version 9.00
# Visual Studio 2005
Project('{E24C65DC-7377-472B-9ABA-BC803B73C61A}') = 'C:\solutions\WebSite2\', '..\..\solutions\WebSite2\', '{F90528C4-6989-4D33-AFE8-F53173597CC2}'
ProjectSection(WebsiteProperties) = preProject
Debug.AspNetCompiler.VirtualPath = '/WebSite2'
Debug.AspNetCompiler.PhysicalPath = '..\..\solutions\WebSite2\'
Debug.AspNetCompiler.TargetPath = 'PrecompiledWeb\WebSite2\'
Debug.AspNetCompiler.Updateable = 'true'
Debug.AspNetCompiler.ForceOverwrite = 'true'
Debug.AspNetCompiler.FixedNames = 'true'
Debug.AspNetCompiler.Debug = 'True'
Release.AspNetCompiler.VirtualPath = '/WebSite2'
Release.AspNetCompiler.PhysicalPath = '..\..\solutions\WebSite2\'
Release.AspNetCompiler.TargetPath = 'PrecompiledWeb\WebSite2\'
Release.AspNetCompiler.Updateable = 'true'
Release.AspNetCompiler.ForceOverwrite = 'true'
Release.AspNetCompiler.FixedNames = 'true'
Release.AspNetCompiler.Debug = 'False'
VWDPort = '2776'
DefaultWebSiteLanguage = 'Visual C#'
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{F90528C4-6989-4D33-AFE8-F53173597CC2}.Debug|Any CPU.ActiveCfg = Debug|.NET
{F90528C4-6989-4D33-AFE8-F53173597CC2}.Debug|Any CPU.Build.0 = Debug|.NET
EndGlobalSection
EndGlobal";
File.WriteAllText(projectFilePath, solutionContents.Replace('\'', '"'));
try
{
MockLogger logger = new MockLogger();
Engine engine = new Engine();
engine.RegisterLogger(logger);
Project solutionWrapperProject = new Project(engine);
solutionWrapperProject.Load(projectFilePath);
solutionWrapperProject.SetProperty("Configuration", "Nonexistent");
solutionWrapperProject.SetProperty("SkipInvalidConfigurations", "true");
solutionWrapperProject.ToolsVersion = "4.0";
// Build should complete successfully even with an invalid solution config if SkipInvalidConfigurations is true
Assertion.AssertEquals(true, solutionWrapperProject.Build(null, null));
// We should get the invalid solution configuration warning
Assertion.AssertEquals(1, logger.Warnings.Count);
BuildWarningEventArgs warning = logger.Warnings[0];
// Don't look at warning.Code here -- it may be null if PseudoLoc has messed
// with our resource strings. The code will still be in the log -- it just wouldn't get
// pulled out into the code field.
logger.AssertLogContains("MSB4126");
// No errors expected
Assertion.AssertEquals(0, logger.Errors.Count);
}
finally
{
File.Delete(projectFilePath);
}
}
public void SynthesizeLinkMetadataForItemsOnWhitelist()
{
string[] files = null;
string outputPath = Path.GetTempPath() + "\\" + Guid.NewGuid().ToString("N");
string directoryToDelete = null;
try
{
files = Helpers.CreateFiles("class1.cs", "File1.txt", "Content1.foo", "a.proj");
directoryToDelete = Path.GetDirectoryName(files[0]);
string subProjectDirectory = Path.Combine(Path.GetDirectoryName(files[0]), "SubFolder");
Directory.CreateDirectory(subProjectDirectory);
string classPath = Path.Combine(subProjectDirectory, "Class1.cs");
string textFilePath = Path.Combine(subProjectDirectory, "File1.txt");
string contentPath = Path.Combine(subProjectDirectory, "Content1.foo");
File.Move(files[0], classPath);
File.Move(files[1], textFilePath);
File.Move(files[2], contentPath);
string sharedFilesProjectContents =
@"<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<Compile Include=`" + classPath + @"` />
<None Include=`" + textFilePath + @"` />
<Content Include=`" + contentPath + @"` />
</ItemGroup>
</Project>";
File.WriteAllText(files[3], ObjectModelHelpers.CleanupFileContents(sharedFilesProjectContents));
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.CreateInMemoryProject(
@"
<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<PropertyGroup>
<OutputPath>" + outputPath + @"</OutputPath>
<AssemblyName>MyAssembly</AssemblyName>
<OutputType>Library</OutputType>
<Configuration>Debug</Configuration>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<SynthesizeLinkMetadata>true</SynthesizeLinkMetadata>
</PropertyGroup>
<Import Project=`" + files[3] + @"` />
<Import Project=`$(MSBuildToolsPath)\Microsoft.CSharp.Targets` />
<Target Name=`AfterBuild`>
<Message Text=`%(Compile.Identity): [%(Compile.Link)]` />
<Message Text=`%(None.Identity): [%(None.Link)]` />
<Message Text=`%(Content.Identity): [%(Content.Link)]` />
</Target>
</Project>
",
logger
);
project.Build();
logger.AssertLogContains(String.Format(@"{0}: []", classPath));
logger.AssertLogContains(String.Format(@"{0}: [SubFolder\File1.txt]", textFilePath));
logger.AssertLogContains(String.Format(@"{0}: [SubFolder\Content1.foo]", contentPath));
}
finally
{
if (directoryToDelete != null)
{
ObjectModelHelpers.DeleteDirectory(directoryToDelete);
}
ObjectModelHelpers.DeleteDirectory(outputPath);
}
}
public void TestTargetFrameworkPaths()
{
string[] targetFrameworkVersions = { "v2.0", "v3.0", "v3.5", "v4.0", "v4.5", "" };
foreach (var version in targetFrameworkVersions)
{
MockLogger logger = new MockLogger();
string projString = ObjectModelHelpers.CleanupFileContents(
@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` DefaultTargets=`GetPaths` xmlns=`msbuildnamespace`>
<Import Project=`$(MSBuildToolsPath)\Microsoft.CSharp.targets` />
<Target
Name='GetPaths'
DependsOnTargets='GetFrameworkPaths'>
<Message Text='Target Framework Folder = @(_TargetedFrameworkDirectoryItem)' />
</Target>
</Project>"
);
Project project = ObjectModelHelpers.CreateInMemoryProject(
projString,
logger
);
project.SetProperty("TargetFrameworkVersion", version);
project.Build();
string targetFrameworkVersion = project.GetPropertyValue("TargetFrameworkVersion");
string msbuildFrameworkToolsRoot = project.GetPropertyValue("MSBuildFrameworkToolsRoot");
if (targetFrameworkVersion.Equals("v2.0"))
{
if (FrameworkLocationHelper.PathToDotNetFrameworkV20 != null)
{
logger.AssertLogContains(false/* not case sensitive */, "Target Framework Folder = " + FrameworkLocationHelper.PathToDotNetFrameworkV20);
}
else
{
// If Framework v2.0 isn't present we use the hard coded version for this validation
logger.AssertLogContains(false/* not case sensitive */, "Target Framework Folder = " + msbuildFrameworkToolsRoot + "v2.0.50727");
}
}
else if (targetFrameworkVersion.Equals("v3.0") || targetFrameworkVersion.Equals("v3.5"))
{
logger.AssertLogContains(false/* not case sensitive */, "Target Framework Folder = " + msbuildFrameworkToolsRoot + "\\" + targetFrameworkVersion);
}
else if (targetFrameworkVersion.Equals("v4.0"))
{
logger.AssertLogContains(false/* not case sensitive */, "Target Framework Folder = " + FrameworkLocationHelper.PathToDotNetFrameworkV40);
}
else if (targetFrameworkVersion.Equals("v4.5"))
{
logger.AssertLogContains(false/* not case sensitive */, "Target Framework Folder = " + FrameworkLocationHelper.PathToDotNetFrameworkV45);
}
else if (String.IsNullOrEmpty(targetFrameworkVersion))
{
logger.AssertLogContains(false/* not case sensitive */, "Target Framework Folder = " + FrameworkLocationHelper.PathToDotNetFrameworkV45);
}
}
}
public void AnyCPUJupiterProjectWithNoExplicitOutputTypeIs32BitPreferred()
{
string file = null;
string outputPath = Path.GetTempPath() + "\\" + Guid.NewGuid().ToString("N");
try
{
file = Helpers.CreateFiles("class1.cs")[0];
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.CreateInMemoryProject(
@"
<Project DefaultTargets=`Build` ToolsVersion=`4.0` xmlns=`msbuildnamespace`>
<PropertyGroup>
<OutputPath>" + outputPath + @"</OutputPath>
<AssemblyName>MyAssembly</AssemblyName>
<Configuration>Debug</Configuration>
<PlatformTarget>AnyCPU</PlatformTarget>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
</PropertyGroup>
<ItemGroup>
<Compile Include=`" + file + @"` />
</ItemGroup>
<Import Project=`$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v1.0\Microsoft.Windows.UI.Xaml.CSharp.targets` Condition=`Exists('$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v1.0\Microsoft.Windows.UI.Xaml.CSharp.targets')` />
<!-- Fall back to CSharp targets for the sake of this test if the Jupiter targets don't exist, since what we're testing can be equally well resolved by either -->
<Import Project=`$(MSBuildToolsPath)\Microsoft.CSharp.Targets` Condition=`!Exists('$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v1.0\Microsoft.Windows.UI.Xaml.CSharp.targets')` />
</Project>
",
logger
);
project.Build();
logger.AssertLogContains(" /platform:anycpu32bitpreferred");
}
finally
{
if (file != null)
{
File.Delete(file);
}
ObjectModelHelpers.DeleteDirectory(outputPath);
}
}
public void FalseMetadataConditionOnItemDefinitionChildBothQualifiedAndUnqualified()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
<ItemDefinitionGroup>
<i>
<m>m1</m>
<n>n1</n>
</i>
</ItemDefinitionGroup>
<ItemDefinitionGroup>
<i>
<m Condition=`'%(m)'=='m2' or !('%(n)'=='n1') or '%(i.m)' != 'm1'`>m3</m>
</i>
</ItemDefinitionGroup>
<Target Name=`t`>
<Message Text=`[%(i.m)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[m1]");
}
public void TargetNamesAlwaysUnescaped_Override()
{
Project project = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`http://schemas.microsoft.com/developer/msbuild/2003`>
<Target Name=`%3B`>
<Message Text=`[WRONG]` />
</Target>
<Target Name=`;`>
<Message Text=`[OVERRIDE]` />
</Target>
</Project>
");
MockLogger logger = new MockLogger();
bool success = project.Build(logger);
Assert.True(success); // "Build failed. See Standard Out tab for details"
logger.AssertLogContains("[OVERRIDE]");
}
public void GlobalPropertyWithEscapedCharacters()
{
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`http://schemas.microsoft.com/developer/msbuild/2003`>
<Target Name=`Build`>
<Message Text=`MyGlobalProperty = '$(MyGlobalProperty)'` />
</Target>
</Project>
");
project.SetGlobalProperty("MyGlobalProperty", "foo%253bbar");
bool success = project.Build(logger);
Assert.True(success); // "Build failed. See Standard Out tab for details"
logger.AssertLogContains("MyGlobalProperty = 'foo%3bbar'");
}
public void SetGlobalPropertyDuringBuildToValueItAlreadyHas()
{
MockLogger logger = SetPropertyDuringBuild("v1", "v1");
logger.AssertLogContains("[v1]");
}
public void MixtureOfItemAndDefaultMetadata()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<CppCompile Include='a.cpp'>
<WarningLevel>4</WarningLevel>
</CppCompile>
</ItemGroup>
<ItemDefinitionGroup>
<CppCompile>
<Defines>DEBUG</Defines>
</CppCompile>
</ItemDefinitionGroup>
<Target Name=`t`>
<Message Text=`[%(CppCompile.Identity)==%(CppCompile.Defines)]`/>
<Message Text=`[%(CppCompile.Identity)==%(CppCompile.WarningLevel)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[a.cpp==DEBUG]", "[a.cpp==4]");
}
public void ItemDefinitionInTargetErrors()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`t`>
<ItemDefinitionGroup/>
</Target>
</Project>
", logger);
bool result = p.Build("t");
Assertion.AssertEquals(false, result);
logger.AssertLogContains("MSB4163");
}
public void MetadataConditionOnItemDefinitionAndChildQualifiedWithUnrelatedItemType()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
<ItemDefinitionGroup>
<i>
<m>m1</m>
</i>
</ItemDefinitionGroup>
<ItemDefinitionGroup>
<i Condition=`'%(j.m)'=='' and '%(j.m)'!='x'`>
<m Condition=`'%(j.m)'=='' and '%(j.m)'!='x'`>m2</m>
</i>
</ItemDefinitionGroup>
<Target Name=`t`>
<Message Text=`[%(i.m)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[m2]");
}
public void ProjectBuiltUsingMSBuildTaskShouldBuildUsingDefaultToolsVersionIfOneIsNotSpecified()
{
try
{
string projectContent =
@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`a`>
<Message Text=`[a=$(MSBuildToolsVersion)]`/>
<MSBuild Projects=`p2.proj`/>
</Target>
</Project>
";
string projectContent2 =
@"
<Project xmlns=`msbuildnamespace`>
<Target Name=`a`>
<Message Text=`[b=$(MSBuildToolsVersion)]`/>
</Target>
</Project>
";
MockLogger logger = new MockLogger();
Engine e = new Engine();
e.RegisterLogger(logger);
string p1Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("p1.proj", projectContent);
string p2Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("p2.proj", projectContent2);
Project p1 = new Project(e);
p1.Load(p1Path);
p1.Build();
logger.AssertLogContains("[a="+ ObjectModelHelpers.MSBuildDefaultToolsVersion + "]");
Assertion.Assert("Cachescope should have an entry with 4.0", e.CacheManager.GetCacheScope(p1Path, new BuildPropertyGroup(), ObjectModelHelpers.MSBuildDefaultToolsVersion, CacheContentType.BuildResults) != null);
Assertion.Assert("Cachescope should have an entry with default tools version", e.CacheManager.GetCacheScope(p2Path, new BuildPropertyGroup(), e.DefaultToolsVersion, CacheContentType.BuildResults) != null);
}
finally
{
ObjectModelHelpers.DeleteTempProjectDirectory();
}
}
public void TargetNameIsCaseInsensitive()
{
string projectFile1 = ObjectModelHelpers.CreateTempFileOnDisk(@"
<Project DefaultTargets=`Build` xmlns=`msbuildnamespace` ToolsVersion='msbuilddefaulttoolsversion'>
<Target Name=`bUiLd` Outputs=`foo.out` />
</Project>
");
string projectFile2 = ObjectModelHelpers.CreateTempFileOnDisk(@"
<Project DefaultTargets=`t` xmlns=`msbuildnamespace` ToolsVersion=`msbuilddefaulttoolsversion`>
<Target Name=`t`>
<MSBuild Projects=`" + projectFile1 + @"` Targets=`BUILD`>
<Output TaskParameter=`TargetOutputs` ItemName=`out`/>
</MSBuild>
<Message Text=`[@(out)]`/>
</Target>
</Project>
");
try
{
Project project = new Project(projectFile2);
MockLogger logger = new MockLogger();
project.Build(logger);
logger.AssertLogContains("[foo.out]");
}
finally
{
File.Delete(projectFile1);
File.Delete(projectFile2);
}
}
public void MetadataConditionOnItemDefinition()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include='i1'/>
<j Include='j1'/>
</ItemGroup>
<ItemDefinitionGroup>
<i>
<m>m1</m>
</i>
<j>
<n>n1</n>
</j>
</ItemDefinitionGroup>
<ItemDefinitionGroup>
<i Condition=`'%(m)'=='m1'`>
<m>m2</m>
</i>
<!-- verify j metadata is distinct -->
<j Condition=`'%(j.n)'=='n1' and '%(n)'=='n1'`>
<n>n2</n>
</j>
</ItemDefinitionGroup>
<Target Name=`t`>
<Message Text=`[%(i.m)]`/>
<Message Text=`[%(j.n)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[m2]", "[n2]");
}
public void ProjectToolsVersionOverwriteIsTrue()
{
try
{
string projectContent =
@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`a`>
<Message Text=`[a=$(MSBuildToolsVersion)]`/>
<MSBuild Projects=`p2.proj`/>
<MSBuild Projects=`p2.proj` ToolsVersion='3.5'/>
<MSBuild Projects=`p2.proj` ToolsVersion='2.0'/>
</Target>
</Project>
";
string projectContent2 =
@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`a`>
<Message Text=`[b=$(MSBuildToolsVersion)]`/>
</Target>
</Project>
";
MockLogger logger = new MockLogger();
Engine e = new Engine();
e.RegisterLogger(logger);
string p1Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("p1.proj", projectContent);
string p2Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("p2.proj", projectContent2);
Project p1 = new Project(e, "2.0");
p1.Load(p1Path);
p1.Build();
logger.AssertLogContains("[a=2.0]");
logger.AssertLogContains("[b=2.0]");
Assertion.Assert("Cachescope should have an entry with 2.0", e.CacheManager.GetCacheScope(p1Path, new BuildPropertyGroup(), "2.0", CacheContentType.BuildResults) != null);
Assertion.Assert("Cachescope should have an entry with 2.0", e.CacheManager.GetCacheScope(p2Path, new BuildPropertyGroup(), "2.0", CacheContentType.BuildResults) != null);
}
finally
{
ObjectModelHelpers.DeleteTempProjectDirectory();
}
}
public void MutualReferenceToDefinition3()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemDefinitionGroup>
<i>
<m>m1</m>
<n>%(i.m)</n>
<o>%(j.m)</o>
</i>
</ItemDefinitionGroup>
<ItemGroup>
<i Include=`i1`/>
</ItemGroup>
<Target Name=`t`>
<Message Text=`[%(i.m)][%(i.n)][%(i.o)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[m1][m1][]");
}
public void ProjectReevaluationReevaluatesItemDefinitions()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<PropertyGroup>
<Defines>CODEANALYSIS</Defines>
</PropertyGroup>
<ItemGroup>
<CppCompile Include='a.cpp'/>
</ItemGroup>
<ItemDefinitionGroup>
<CppCompile>
<Defines Condition=`'$(BuildFlavor)'=='ret'`>$(Defines);RETAIL</Defines>
<Defines Condition=`'$(BuildFlavor)'=='chk'`>$(Defines);DEBUG</Defines>
</CppCompile>
</ItemDefinitionGroup>
<Target Name=`t`>
<Message Text=`[%(CppCompile.Identity)==%(CppCompile.Defines)]`/>
</Target>
</Project>
", logger);
p.SetProperty("BuildFlavor", "ret");
p.Build("t");
logger.AssertLogContains("[a.cpp==CODEANALYSIS;RETAIL]");
BuildItemGroup group = p.GetEvaluatedItemsByName("CppCompile");
BuildItem item = group[0];
string metadataValue = item.GetMetadata("Defines");
Assertion.AssertEquals("CODEANALYSIS;RETAIL", metadataValue);
p.SetProperty("BuildFlavor", "chk");
group = p.GetEvaluatedItemsByName("CppCompile");
item = group[0];
metadataValue = item.GetMetadata("Defines");
Assertion.AssertEquals("CODEANALYSIS;DEBUG", metadataValue);
}
public void MSBuildCallDoesNotAffectCallingProjectsDefinitions()
{
string otherProject = null;
try
{
otherProject = Path.GetTempFileName();
string otherProjectContent = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
<ItemDefinitionGroup>
<i>
<m>m2</m>
</i>
</ItemDefinitionGroup>
<Target Name=""t"">
<Message Text=""[CHILD:%(i.m)]""/>
</Target>
</Project>";
using (StreamWriter writer = new StreamWriter(otherProject))
{
writer.Write(otherProjectContent);
}
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
<ItemDefinitionGroup>
<i>
<m>m1</m>
</i>
</ItemDefinitionGroup>
<Target Name=`t`>
<Message Text=`[PARENT-before:%(i.m)]`/>
<MSBuild Projects=`" + otherProject + @"`/>
<Message Text=`[PARENT-after:%(i.m)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[PARENT-before:m1]", "[CHILD:m2]", "[PARENT-after:m1]");
}
finally
{
File.Delete(otherProject);
}
}
public void TestGetFrameworkPaths()
{
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.CreateInMemoryProject(
@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` DefaultTargets=`GetPaths` xmlns=`msbuildnamespace`>
<Target Name=`GetPaths` DependsOnTargets=`GetFrameworkPaths`>
<Message Text=`Framework 4.0 = @(_TargetFramework40DirectoryItem)` Importance=`High`/>
<Message Text=`Framework 3.5 = @(_TargetFramework35DirectoryItem)` Importance=`High`/>
<Message Text=`Framework 3.0 = @(_TargetFramework30DirectoryItem)` Importance=`High`/>
<Message Text=`Framework 2.0 = @(_TargetFramework20DirectoryItem)` Importance=`High`/>
</Target>
<Import Project=`$(MSBuildToolsPath)\Microsoft.CSharp.targets` />
</Project>",
logger
);
project.Build();
logger.AssertLogContains(false/* not case sensitive */, "Framework 4.0 = " + FrameworkLocationHelper.PathToDotNetFrameworkV40);
// Only check .NET 3.5 and below if they're actually on the box.
if (FrameworkLocationHelper.PathToDotNetFrameworkV35 != null)
{
logger.AssertLogContains(false/* not case sensitive */, "Framework 3.5 = " + FrameworkLocationHelper.PathToDotNetFrameworkV35);
logger.AssertLogContains(false/* not case sensitive */, "Framework 3.0 = " + FrameworkLocationHelper.PathToDotNetFrameworkV30);
logger.AssertLogContains(false/* not case sensitive */, "Framework 2.0 = " + FrameworkLocationHelper.PathToDotNetFrameworkV20);
}
}
public void DefaultMetadataTravelWithTargetOutputs()
{
string otherProject = null;
try
{
otherProject = Path.GetTempFileName();
string otherProjectContent = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<i Include='i1'>
<m>m1</m>
</i>
</ItemGroup>
<ItemDefinitionGroup>
<i>
<n>n1</n>
</i>
</ItemDefinitionGroup>
<Target Name=""t"" Outputs=""@(i)"">
<Message Text=""[CHILD:%(i.Identity):m=%(i.m),n=%(i.n)]""/>
</Target>
</Project>";
using (StreamWriter writer = new StreamWriter(otherProject))
{
writer.Write(otherProjectContent);
}
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`t`>
<MSBuild Projects=`" + otherProject + @"`>
<Output TaskParameter='TargetOutputs' ItemName='i'/>
</MSBuild>
<Message Text=`[PARENT:%(i.Identity):m=%(i.m),n=%(i.n)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[CHILD:i1:m=m1,n=n1]", "[PARENT:i1:m=m1,n=n1]");
}
finally
{
File.Delete(otherProject);
}
}
public void NoLinkMetadataSynthesisWhenDefinedInProject()
{
string[] files = null;
string outputPath = Path.GetTempPath() + "\\" + Guid.NewGuid().ToString("N");
try
{
files = Helpers.CreateFiles("class1.cs", "File1.txt", "Content1.foo");
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.CreateInMemoryProject(
@"
<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<PropertyGroup>
<OutputPath>" + outputPath + @"</OutputPath>
<AssemblyName>MyAssembly</AssemblyName>
<OutputType>Library</OutputType>
<Configuration>Debug</Configuration>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<SynthesizeLinkMetadata>true</SynthesizeLinkMetadata>
</PropertyGroup>
<ItemGroup>
<Compile Include=`" + files[0] + @"` />
<None Include=`" + files[1] + @"` />
<Content Include=`" + files[2] + @"` />
</ItemGroup>
<Import Project=`$(MSBuildToolsPath)\Microsoft.CSharp.Targets` />
<Target Name=`AfterBuild`>
<Message Text=`%(Compile.Identity): [%(Compile.Link)]` />
<Message Text=`%(None.Identity): [%(None.Link)]` />
<Message Text=`%(Content.Identity): [%(Content.Link)]` />
</Target>
</Project>
",
logger
);
project.Build();
logger.AssertLogContains(String.Format("{0}: []", files[0]));
logger.AssertLogContains(String.Format("{0}: []", files[1]));
logger.AssertLogContains(String.Format("{0}: []", files[2]));
}
finally
{
if (files != null)
{
foreach (string file in files)
{
File.Delete(file);
}
}
ObjectModelHelpers.DeleteDirectory(outputPath);
}
}
public void EscapeOutputItemspecs()
{
string projectContents = @"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name=`t` >
<CreateItem Include=`%2520`><!-- should be a literal %20 not a space -->
<Output TaskParameter=`Include` ItemName=`Include`/>
</CreateItem>
<Message Text=`@(include)` Importance=`high`/>
</Target>
</Project>
";
Project p = ObjectModelHelpers.CreateInMemoryProject(projectContents);
MockLogger l = new MockLogger();
p.ParentEngine.RegisterLogger(l);
p.Build(new string[] { "t" }, null);
Assertion.Assert(l.ErrorCount == 0);
Assertion.Assert(l.WarningCount == 0);
l.AssertLogContains("%20");
}
public void IntrinsicTaskModifyingDefaultMetadata()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
<ItemDefinitionGroup>
<i>
<m>m1</m>
</i>
</ItemDefinitionGroup>
<Target Name=`t`>
<ItemGroup>
<i>
<m>m2</m>
</i>
</ItemGroup>
<Message Text=`[%(i.m)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[m2]");
BuildItemGroup group = p.GetEvaluatedItemsByName("i");
BuildItem item = group[0];
string metadataValue = item.GetMetadata("m");
Assertion.AssertEquals("m2", metadataValue);
p.ResetBuildStatus();
// Should go back to definition
group = p.GetEvaluatedItemsByName("i");
item = group[0];
metadataValue = item.GetMetadata("m");
Assertion.AssertEquals("m1", metadataValue);
}
public void FailingTaskStillPublishesOutputs()
{
MockLogger l = new MockLogger();
string resx = Path.Combine(Path.GetTempPath(), "FailingTaskStillPublishesOutputs.resx");
try
{
File.WriteAllText(resx, @"
<root>
<resheader name=""resmimetype"">
<value>text/microsoft-resx</value>
</resheader>
<resheader name=""version"">
<value>2.0</value>
</resheader>
<resheader name=""reader"">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name=""writer"">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name=""a"">
<value>aa</value>
</data>
<data name=""b"">
<value>bb</value>
</data>
</root>");
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<Target Name='Build'>
<GenerateResource
Sources='" + resx + @"'
ExecuteAsTool='false'
StronglyTypedLanguage='!@:|'>
<Output TaskParameter='FilesWritten' ItemName='FilesWrittenItem'/>
<Output TaskParameter='FilesWritten' PropertyName='FilesWrittenProperty'/>
</GenerateResource>
<OnError ExecuteTargets='ErrorTarget'/>
</Target>
<Target Name='ErrorTarget'>
<Message Text='[@(fileswrittenitem)]'/>
<Message Text='[$(fileswrittenproperty)]'/>
</Target>
</Project>",
l
);
p.Build(new string[] { "Build" }, null);
string resource = Path.ChangeExtension(resx, ".resources");
Assertion.Assert("Expected one error because 'Build' failed.", l.ErrorCount >= 1);
l.AssertLogContains("[" + resource + "]", "[" + resource + "]");
// And outputs are visible at the project level
Assertion.AssertEquals(resource, p.GetEvaluatedItemsByName("FilesWrittenItem")[0].FinalItemSpec);
Assertion.AssertEquals(resource, p.GetEvaluatedProperty("FilesWrittenProperty"));
p.ResetBuildStatus();
// But are gone after resetting of course
Assertion.AssertEquals(0, p.GetEvaluatedItemsByName("FilesWrittenItem").Count);
Assertion.AssertEquals(null, p.GetEvaluatedProperty("FilesWrittenProperty"));
}
finally
{
File.Delete(resx);
}
}
public void IntrinsicTaskConsumingDefaultMetadata()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<i Include='i1'/>
</ItemGroup>
<ItemDefinitionGroup>
<i>
<m>m1</m>
</i>
</ItemDefinitionGroup>
<Target Name=`t`>
<ItemGroup>
<i Condition=`'%(i.m)'=='m1'`>
<n Condition=`'%(m)'=='m1'`>n2</n>
</i>
</ItemGroup>
<Message Text=`[%(i.n)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[n2]");
}
public void DefinitionInImportedFile()
{
MockLogger logger = new MockLogger();
string importedFile = null;
try
{
importedFile = Path.GetTempFileName();
File.WriteAllText(importedFile, @"
<Project ToolsVersion='3.5' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<ItemDefinitionGroup>
<CppCompile>
<Defines>DEBUG</Defines>
</CppCompile>
</ItemDefinitionGroup>
</Project>
");
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemGroup>
<CppCompile Include='a.cpp'/>
</ItemGroup>
<Import Project='" + importedFile + @"'/>
<Target Name=`t`>
<Message Text=`[%(CppCompile.Identity)==%(CppCompile.Defines)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[a.cpp==DEBUG]");
}
finally
{
ObjectModelHelpers.DeleteTempFiles(new string[] { importedFile });
}
}
public void EscapedWildcardsShouldNotBeExpanded_InTaskHost()
{
MockLogger logger = new MockLogger();
try
{
// Populate the project directory with three physical files on disk -- a.weirdo, b.weirdo, c.weirdo.
EscapingInProjectsHelper.CreateThreeWeirdoFiles();
Project project = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`http://schemas.microsoft.com/developer/msbuild/2003`>
<UsingTask TaskName=`Message` AssemblyFile=`$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll` TaskFactory=`TaskHostFactory` />
<Target Name=`t`>
<ItemGroup>
<type Include=`%2A` Exclude=``/>
</ItemGroup>
<Message Text=`[@(type)]`/>
</Target>
</Project>
");
bool success = project.Build(logger);
Assert.True(success); // "Build failed. See Standard Out tab for details"
logger.AssertLogContains("[*]");
}
finally
{
EscapingInProjectsHelper.CleanupWeirdoFiles();
}
}
public void ItemsEmittedByIntrinsicTaskPickUpItemDefinitions()
{
MockLogger logger = new MockLogger();
Project p = ObjectModelHelpers.CreateInMemoryProject(@"
<Project ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<ItemDefinitionGroup>
<i>
<m>m1</m>
<n>n1</n>
</i>
</ItemDefinitionGroup>
<Target Name=`t`>
<ItemGroup>
<i Include=`i1`>
<n>n2</n>
</i>
</ItemGroup>
<Message Text=`[%(i.m)][%(i.n)]`/>
</Target>
</Project>
", logger);
p.Build("t");
logger.AssertLogContains("[m1][n2]");
}
public void SemicolonInConfiguration_UsingTaskHost()
{
string originalOverrideTaskHostVariable = Environment.GetEnvironmentVariable("MSBUILDFORCEALLTASKSOUTOFPROC");
try
{
Environment.SetEnvironmentVariable("MSBUILDFORCEALLTASKSOUTOFPROC", "1");
ObjectModelHelpers.DeleteTempProjectDirectory();
// ---------------------
// Foo.csproj
// ---------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory("foo.csproj", @"
<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`http://schemas.microsoft.com/developer/msbuild/2003`>
<Import Project=`$(MSBuildBinPath)\Microsoft.Common.props` />
<PropertyGroup>
<Configuration Condition=` '$(Configuration)' == '' `>Debug</Configuration>
<Platform Condition=` '$(Platform)' == '' `>AnyCPU</Platform>
<OutputType>Library</OutputType>
<AssemblyName>ClassLibrary16</AssemblyName>
</PropertyGroup>
<PropertyGroup Condition=` '$(Configuration)|$(Platform)' == 'a%3bb%27c|AnyCPU' `>
<OutputPath>bin\a%3bb%27c\</OutputPath>
</PropertyGroup>
<ItemGroup>
<Reference Include=`System` />
<Compile Include=`Class1.cs` />
</ItemGroup>
<Import Project=`$(MSBuildBinPath)\Microsoft.CSharp.targets` />
</Project>
");
// ---------------------
// Class1.cs
// ---------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory("Class1.cs", @"
namespace ClassLibrary16
{
public class Class1
{
}
}
");
// Create a logger.
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.LoadProjectFileInTempProjectDirectory("foo.csproj");
// Build the default targets using the Configuration "a;b'c".
project.SetGlobalProperty("Configuration", EscapingUtilities.Escape("a;b'c"));
bool success = project.Build(logger);
Assert.True(success); // "Build failed. See Standard Out tab for details"
ObjectModelHelpers.AssertFileExistsInTempProjectDirectory(@"obj\a;b'c\ClassLibrary16.dll");
ObjectModelHelpers.AssertFileExistsInTempProjectDirectory(@"bin\a;b'c\ClassLibrary16.dll");
logger.AssertLogContains(String.Format("foo -> {0}", Path.Combine(ObjectModelHelpers.TempProjectDir, @"bin\a;b'c\ClassLibrary16.dll")));
}
finally
{
Environment.SetEnvironmentVariable("MSBUILDFORCEALLTASKSOUTOFPROC", originalOverrideTaskHostVariable);
}
}
public void TestSkipInvalidConfigurationsCase()
{
string tmpFileName = Path.GetTempFileName();
File.Delete(tmpFileName);
string projectFilePath = tmpFileName + ".sln";
string solutionContents =
@"
Microsoft Visual Studio Solution File, Format Version 9.00
# Visual Studio 2005
Project('{E24C65DC-7377-472B-9ABA-BC803B73C61A}') = 'C:\solutions\WebSite2\', '..\..\solutions\WebSite2\', '{F90528C4-6989-4D33-AFE8-F53173597CC2}'
ProjectSection(WebsiteProperties) = preProject
Debug.AspNetCompiler.VirtualPath = '/WebSite2'
Debug.AspNetCompiler.PhysicalPath = '..\..\solutions\WebSite2\'
Debug.AspNetCompiler.TargetPath = 'PrecompiledWeb\WebSite2\'
Debug.AspNetCompiler.Updateable = 'true'
Debug.AspNetCompiler.ForceOverwrite = 'true'
Debug.AspNetCompiler.FixedNames = 'true'
Debug.AspNetCompiler.Debug = 'True'
Release.AspNetCompiler.VirtualPath = '/WebSite2'
Release.AspNetCompiler.PhysicalPath = '..\..\solutions\WebSite2\'
Release.AspNetCompiler.TargetPath = 'PrecompiledWeb\WebSite2\'
Release.AspNetCompiler.Updateable = 'true'
Release.AspNetCompiler.ForceOverwrite = 'true'
Release.AspNetCompiler.FixedNames = 'true'
Release.AspNetCompiler.Debug = 'False'
VWDPort = '2776'
DefaultWebSiteLanguage = 'Visual C#'
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{F90528C4-6989-4D33-AFE8-F53173597CC2}.Debug|Any CPU.ActiveCfg = Debug|.NET
{F90528C4-6989-4D33-AFE8-F53173597CC2}.Debug|Any CPU.Build.0 = Debug|.NET
EndGlobalSection
EndGlobal";
File.WriteAllText(projectFilePath, solutionContents.Replace('\'', '"'));
try
{
MockLogger logger = new MockLogger();
Engine engine = new Engine();
engine.RegisterLogger(logger);
Project solutionWrapperProject = new Project(engine);
solutionWrapperProject.Load(projectFilePath);
solutionWrapperProject.SetProperty("Configuration", "Nonexistent");
solutionWrapperProject.SetProperty("SkipInvalidConfigurations", "true");
solutionWrapperProject.ToolsVersion = "4.0";
// Build should complete successfully even with an invalid solution config if SkipInvalidConfigurations is true
Assertion.AssertEquals(true, solutionWrapperProject.Build(null, null));
// We should get the invalid solution configuration warning
Assertion.AssertEquals(1, logger.Warnings.Count);
BuildWarningEventArgs warning = logger.Warnings[0];
// Don't look at warning.Code here -- it may be null if PseudoLoc has messed
// with our resource strings. The code will still be in the log -- it just wouldn't get
// pulled out into the code field.
logger.AssertLogContains("MSB4126");
// No errors expected
Assertion.AssertEquals(0, logger.Errors.Count);
}
finally
{
File.Delete(projectFilePath);
}
}
