internal void BuildInternal(BuildProject project, params string[] targets)
{
if (project != null)
{
BuildProperty platform = project.GlobalProperties["Platform"];
if (platform == null)
{
project.GlobalProperties["Platform"] = platform = new BuildProperty("Platform", "AnyCPU");
}
if (string.IsNullOrEmpty(platform.Value))
{
platform.Value = "AnyCPU";
}
project.ParentEngine.GlobalProperties["SolutionDir"] = solution.GlobalProperties["SolutionDir"];
BuildStarted(delegate()
{
outputs.Clear();
try
{
bool res = project.Build(targets, outputs);
}
catch
{
if (!bl.cancel)
{
throw;
}
}
InvokeBuildCompleted();
});
}
}
public void Build(string rootDirectory, string intermediateDirectory, string outputDirectory, string targetPlatform)
{
AddContentBuildTask(intermediateDirectory, outputDirectory, rootDirectory, targetPlatform);
AddXActBuildTask(intermediateDirectory, outputDirectory, rootDirectory, targetPlatform);
m_project.Build("Build");
}
public Assembly CompileProject(string projectFileName)
{
Assembly existing;
if (Compilations.TryGetValue(Path.GetFullPath(projectFileName), out existing))
{
return existing;
}
var project = new Microsoft.Build.BuildEngine.Project();
project.Load(projectFileName);
var projectName = Environment.NameTable.GetNameFor(project.EvaluatedProperties["AssemblyName"].Value);
var projectPath = project.FullFileName;
var compilerOptions = new SpecSharpOptions();
var assemblyReferences = new List<IAssemblyReference>();
var moduleReferences = new List<IModuleReference>();
var programSources = new List<SpecSharpSourceDocument>();
var assembly = new SpecSharpAssembly(projectName, projectPath, Environment, compilerOptions, assemblyReferences, moduleReferences, programSources);
var helper = new SpecSharpCompilationHelper(assembly.Compilation);
Compilations[Path.GetFullPath(projectFileName)] = assembly;
assemblyReferences.Add(Environment.LoadAssembly(Environment.CoreAssemblySymbolicIdentity));
project.Build("ResolveAssemblyReferences");
foreach (BuildItem item in project.GetEvaluatedItemsByName("ReferencePath"))
{
var assemblyName = new System.Reflection.AssemblyName(item.GetEvaluatedMetadata("FusionName"));
var name = Environment.NameTable.GetNameFor(assemblyName.Name);
var culture = assemblyName.CultureInfo != null ? assemblyName.CultureInfo.Name : "";
var version = assemblyName.Version == null ? new Version(0, 0) : assemblyName.Version;
var token = assemblyName.GetPublicKeyToken();
if (token == null) token = new byte[0];
var location = item.FinalItemSpec;
var identity = new AssemblyIdentity(name, culture, version, token, location);
var reference = Environment.LoadAssembly(identity);
assemblyReferences.Add(reference);
}
foreach (BuildItem item in project.GetEvaluatedItemsByName("ProjectReference"))
{
var name = Environment.NameTable.GetNameFor(Path.GetFileNameWithoutExtension(item.FinalItemSpec));
var location = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(project.FullFileName), item.FinalItemSpec));
var reference = CompileProject(location);
assemblyReferences.Add(reference);
}
foreach (BuildItem item in project.GetEvaluatedItemsByName("Compile"))
{
var location = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(project.FullFileName), item.FinalItemSpec));
var name = Environment.NameTable.GetNameFor(location);
var programSource = new SpecSharpSourceDocument(helper, name, location, File.ReadAllText(location));
programSources.Add(programSource);
}
return assembly;
}
public void TestHintPath1 ()
{
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (ResolveAssembly (null, @"Test\resources\test.dll"));
Assert.IsTrue (project.Build ("A"), "A1");
big = project.GetEvaluatedItemsByName ("ResolvedFiles");
Assert.AreEqual (1, big.Count, "A2");
Assert.IsTrue (big [0].Include.EndsWith (".dll"), "A3");
}
public void ResolveBinary_FancyStuff ()
{
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (ResolveAssembly (null, @"Test\resources\binary\FancyStuff.dll"));
Assert.IsTrue (project.Build ("A"), "A1");
big = project.GetEvaluatedItemsByName ("ResolvedFiles");
Assert.AreEqual (1, big.Count, "A2");
Assert.IsTrue (big[0].Include.EndsWith ("FancyStuff.dll"), "A3");
big = project.GetEvaluatedItemsByName ("ResolvedDependencyFiles");
Assert.AreEqual (1, big.Count, "A4");
Assert.IsTrue (big.Cast<BuildItem> ().Any (item => item.Include.EndsWith ("SimpleWrite.dll")), "A5");
}
public void TestGac1 ()
{
var gacDir = GetGacDir ();
if (gacDir == null || !System.IO.Directory.Exists (gacDir))
Assert.Ignore ("GAC not found.");
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (ResolveAssembly ("System", null));
Assert.IsTrue (project.Build ("A"), "A1");
big = project.GetEvaluatedItemsByName ("ResolvedFiles");
Assert.AreEqual (1, big.Count, "A2");
Assert.IsTrue (big [0].Include.EndsWith (".dll"), "A3");
}
public void TestGac1 ()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<Reference Include='System' />
</ItemGroup>
<PropertyGroup>
<SearchPaths>
{CandidateAssemblyFiles};
$(ReferencePath);
{HintPathFromItem};
{TargetFrameworkDirectory};
{AssemblyFolders};
{GAC};
{RawFileName};
$(OutputPath)
</SearchPaths>
</PropertyGroup>
<Target Name='A'>
<ResolveAssemblyReference
Assemblies='@(Reference)'
SearchPaths='$(SearchPaths)'
>
<Output TaskParameter='ResolvedFiles' ItemName='ResolvedFiles'/>
</ResolveAssemblyReference>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
Assert.IsTrue (project.Build ("A"), "A1");
big = project.GetEvaluatedItemsByName ("ResolvedFiles");
Assert.AreEqual (1, big.Count, "A2");
Assert.IsTrue (big [0].Include.EndsWith (".dll"), "A3");
}
public void RestoringProjectIdFromCache()
{
string childProject = ObjectModelHelpers.CreateTempFileOnDisk(@"
<Project xmlns=`http://schemas.microsoft.com/developer/msbuild/2003`>
<Target Name=`Build`>
<Message Text=`Hi`/>
</Target>
</Project>
");
string mainProject = ObjectModelHelpers.CreateTempFileOnDisk(@"
<Project xmlns=`http://schemas.microsoft.com/developer/msbuild/2003`>
<Target Name=`Build`>
<MSBuild Projects=`{0}` UnloadProjectsOnCompletion=`true` UseResultsCache=`true`/>
<MSBuild Projects=`{0}` UnloadProjectsOnCompletion=`true` UseResultsCache=`true`/>
</Target>
</Project>
", childProject);
ProjectIdLogger logger = new ProjectIdLogger();
Engine engine = new Engine();
engine.RegisterLogger(logger);
Project project = new Project(engine, "4.0");
project.Load(mainProject);
bool success = project.Build(null, null);
Assertion.Assert("Build failed. See Standard Out tab for details", success);
Assert.AreEqual(3, logger.ProjectStartedEvents.Count);
// Project ID should be preserved between runs
Assert.AreEqual(logger.ProjectStartedEvents[1].ProjectId, logger.ProjectStartedEvents[2].ProjectId);
// Project context ID should be different for every entry into the project.
Assert.AreNotEqual(logger.ProjectStartedEvents[1].BuildEventContext.ProjectContextId, logger.ProjectStartedEvents[2].BuildEventContext.ProjectContextId);
}
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 RecursiveDirPathWithParentheses()
{
string directory = null, subdirectory = null, file1 = null;
try
{
directory = Path.Combine(Path.GetTempPath(), "a(b)c");
subdirectory = Path.Combine(directory, "d");
file1 = Path.Combine(subdirectory, "e");
Directory.CreateDirectory(subdirectory);
// Create a file "%temp%\a(b)c\d\e"
File.WriteAllText(file1, String.Empty);
string xml = @"
<Project xmlns=`http://schemas.microsoft.com/developer/msbuild/2003`>
<ItemGroup>
<i Include=`" + directory + @"\**\*" + @"`/>
</ItemGroup>
<Target Name=`t`>
<Message Text=`[%(i.identity)-->c:\foo\%(i.recursivedir)%(i.filename)%(i.extension)]`/>
</Target>
</Project>
";
Console.WriteLine(xml);
Project p = new Project();
p.FullFileName = Path.Combine(subdirectory, "x.proj");
p.LoadXml(xml.Replace('`', '"'));
MockLogger logger = new MockLogger();
p.ParentEngine.RegisterLogger(logger);
p.Build();
logger.AssertLogContains("[" + directory + @"\d\e-->c:\foo\d\e]");
}
finally
{
File.Delete(file1);
Directory.Delete(subdirectory);
Directory.Delete(directory);
}
}
public void TestExecution1 ()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='1'>
<Error Text='Text' HelpKeyword='HelpKeyword' Code='Code' />
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
bool result = project.Build ("1");
Assert.AreEqual (false, result, "#1");
}
public bool BuildProject(Project project)
{
if (project == null)
throw new ArgumentException ("project");
builtTargetsOutputByName.Clear ();
return project.Build ();
}
public void TestExecution ()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='1'>
<Message Text='Text1' Importance='Low'/>
<Message Text='Text2' Importance='Normal'/>
<Message Text='Text3' Importance='High'/>
<Message Text='Text4' Importance='low'/>
<Message Text='Text5' Importance='normal'/>
<Message Text='Text6' Importance='high'/>
<Message Text='Text7' />
<Message Text='Text8' Importance='weird_importance'/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
if (project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build should have failed");
}
Assert.AreEqual (0, testLogger.CheckAny ("Text1", MessageImportance.Low), "A1");
Assert.AreEqual (0, testLogger.CheckAny ("Text2", MessageImportance.Normal), "A2");
Assert.AreEqual (0, testLogger.CheckAny ("Text3", MessageImportance.High), "A3");
Assert.AreEqual (0, testLogger.CheckAny ("Text4", MessageImportance.Low), "A4");
Assert.AreEqual (0, testLogger.CheckAny ("Text5", MessageImportance.Normal), "A5");
Assert.AreEqual (0, testLogger.CheckAny ("Text6", MessageImportance.High), "A6");
Assert.AreEqual (0, testLogger.CheckAny ("Text7", MessageImportance.Normal), "A7");
Assert.AreEqual (1, testLogger.CheckAny ("Text8", MessageImportance.Normal), "A8");
}
public void TestDuplicate1 ()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<UsingTask
AssemblyFile='Test/resources/TestTasks.dll'
TaskName='TrueTestTask'
/>
<UsingTask
AssemblyFile='Test/resources/TestTasks.dll'
TaskName='TrueTestTask'
/>
<Target Name='1'>
<TrueTestTask/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
project.LoadXml (documentString);
if (!project.Build ("1")) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
Assert.AreEqual (2, project.UsingTasks.Count, "A0");
foreach (UsingTask ut in project.UsingTasks) {
Assert.AreEqual ("Test/resources/TestTasks.dll", ut.AssemblyFile, "A1");
Assert.IsNull (ut.AssemblyName, "A2");
Assert.AreEqual (null, ut.Condition, "A3");
Assert.AreEqual (false, ut.IsImported, "A4");
Assert.AreEqual ("TrueTestTask", ut.TaskName, "A5");
}
}
public void S3ExistsPrefixProjectFile()
{
if (!IsEmpty)
{
string prefix = Guid.NewGuid().ToString();
string key = prefix + "/jquery.min.js";
Project project = new Project(Engine.GlobalEngine);
project.Load("S3Exists.proj");
BuildPropertyGroup properties = project.AddNewPropertyGroup(false);
properties.AddNewProperty("Prefix", prefix);
properties.AddNewProperty("S3AccessKeyId", AccessKeyId);
properties.AddNewProperty("S3BucketName", BucketName);
properties.AddNewProperty("S3SecretAccessKeyId", SecretAccessKeyId);
properties.AddNewProperty("S3UseSsl", UseSsl.ToString());
project.Build("PrefixExists");
PutObjectRequest request = new PutObjectRequest()
.WithBucketName(BucketName)
.WithKey(key)
.WithFilePath(@"script\jquery.min.js");
using (PutObjectResponse response = Client.PutObject(request))
{
cleanupKeys.Add(key);
}
project.Build("PrefixExists");
}
}
public void TestImportEmptyVariableWithConditionFalse ()
{
string documentString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Import Project='$(ImportPath)' Condition='false' />
<Target Name='Build' />
</Project>";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
Assert.IsTrue (project.Build ("Build"), "Build failed");
}
public void TestExecution ()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='1'>
<Message Text='Text' Importance='Low'/>
<Message Text='Text' Importance='Normal'/>
<Message Text='Text' Importance='High'/>
<Message Text='Text' Importance='low'/>
<Message Text='Text' Importance='normal'/>
<Message Text='Text' Importance='high'/>
<Message Text='Text' />
<Message Text='Text' Importance='weird_importance'/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
project.Build ("1");
Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Low), "A1");
Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Normal), "A2");
Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.High), "A3");
Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Low), "A4");
Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Normal), "A5");
Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.High), "A6");
Assert.AreEqual (0, testLogger.CheckHead ("Text", MessageImportance.Normal), "A7");
Assert.AreEqual (1, testLogger.CheckHead ("Text", MessageImportance.Normal), "A8");
}
public void BuildProjectWithReservedGlobalProperty()
{
string childProject = ObjectModelHelpers.CreateTempFileOnDisk(@"
<Project xmlns=`http://schemas.microsoft.com/developer/msbuild/2003`>
<Target Name=`1`></Target>
</Project>
");
string mainProject = ObjectModelHelpers.CreateTempFileOnDisk(@"
<Project xmlns=`http://schemas.microsoft.com/developer/msbuild/2003`>
<Target Name=`1`>
<MSBuild Projects=`@(ProjectReference)`/>
</Target>
<ItemGroup>
<ProjectReference Include=`{0}`><Properties>Target=1</Properties></ProjectReference>
</ItemGroup>
</Project>
", childProject);
ProjectIdLogger logger = new ProjectIdLogger();
Engine engine = new Engine();
engine.RegisterLogger(logger);
Project project = new Project(engine, "4.0");
project.Load(mainProject);
bool success = project.Build(null, null);
Assertion.Assert("Build succeded and should have failed. See Standard Out tab for details", !success);
}
public void TestOverridingTargets ()
{
Engine engine;
Project project;
string second = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='BeforeBuild'/>
<Target Name='AfterBuild'/>
<Target Name='Build' DependsOnTargets='BeforeBuild'>
<Message Text='Build executing'/>
<CallTarget Targets='AfterBuild'/>
</Target>
</Project>";
using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
sw.Write (second);
}
string documentString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='AfterBuild'>
<Message Text='Overriding AfterBuild'/>
</Target>
<Import Project='Test/resources/second.proj'/>
<Target Name='BeforeBuild'>
<Message Text='Overriding BeforeBuild'/>
</Target>
</Project>";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
bool result = project.Build ("Build");
if (!result) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
logger.CheckLoggedMessageHead ("Overriding BeforeBuild", "A1");
logger.CheckLoggedMessageHead ("Build executing", "A1");
Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
}
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 TestTargetReturns ()
{
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.Load (Path.Combine ("Test", Path.Combine ("resources", "TestReturns.csproj")));
var logger = new TestMessageLogger ();
engine.RegisterLogger (logger);
bool result = project.Build ("Main");
if (!result) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
logger.CheckLoggedMessageHead ("Result: Bar", "A1");
Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
}
public void TestLazyLoad1 ()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<UsingTask
AssemblyFile='NonExistantAssembly.dll'
TaskName='SimpleTask'
/>
<Target Name='1'>
<Message Text='hello'/>
</Target>
<Target Name='2'>
<SimpleTask Foo='bar'/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
project.LoadXml (documentString);
if (!project.Build ("1")) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
if (project.Build ("2"))
Assert.Fail ("Build should've failed, as a task from a nonexistant assembly is referenced");
IEnumerator en = project.UsingTasks.GetEnumerator ();
en.MoveNext ();
UsingTask ut = (UsingTask) en.Current;
Assert.AreEqual ("NonExistantAssembly.dll", ut.AssemblyFile, "A1");
Assert.IsNull (ut.AssemblyName, "A2");
Assert.AreEqual (null, ut.Condition, "A3");
Assert.AreEqual (false, ut.IsImported, "A4");
Assert.AreEqual ("SimpleTask", ut.TaskName, "A5");
}
public void TestImportProjectWithConditionReferencingExtensionPath ()
{
string documentString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Import Project='$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets' Condition=""Exists('$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets')"" />
<Target Name='Build' />
</Project>";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
Assert.IsTrue (project.Build ("Build"), "Build failed");
}
public void TestTargetOutputsIncludingMetadata ()
{
Engine engine;
Project project;
string documentString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<fruit Include=""apple""><md>a</md></fruit>
<fruit Include=""rhubarb""><md>b</md></fruit>
<fruit Include=""apricot""><md>c</md></fruit>
</ItemGroup>
<Target Name=""Main"">
<CallTarget Targets=""foo"">
<Output TaskParameter=""TargetOutputs"" ItemName=""AllOut""/>
</CallTarget>
<CallTarget Targets=""foo"">
<Output TaskParameter=""TargetOutputs"" ItemName=""AllOut""/>
</CallTarget>
<Message Text=""AllOut: @(AllOut) metadata: %(AllOut.md)""/>
</Target>
<Target Name=""foo"" Outputs=""@(FooItem)"">
<Message Text=""foo called""/>
<CreateItem Include=""@(fruit)"">
<Output TaskParameter=""Include"" ItemName=""FooItem""/>
</CreateItem>
<Message Text=""FooItem: @(FooItem) metadata: %(FooItem.md)""/>
</Target>
</Project>";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
bool result = project.Build ("Main");
if (!result) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
try {
logger.CheckLoggedMessageHead ("foo called", "A1");
logger.CheckLoggedMessageHead ("FooItem: apple metadata: a", "A2");
logger.CheckLoggedMessageHead ("FooItem: rhubarb metadata: b", "A3");
logger.CheckLoggedMessageHead ("FooItem: apricot metadata: c", "A4");
logger.CheckLoggedMessageHead ("AllOut: apple;apple metadata: a", "A5");
logger.CheckLoggedMessageHead ("AllOut: rhubarb;rhubarb metadata: b", "A6");
logger.CheckLoggedMessageHead ("AllOut: apricot;apricot metadata: c", "A7");
Assert.AreEqual (0, logger.NormalMessageCount, "Extra messages found");
Assert.AreEqual (2, logger.TargetStarted, "TargetStarted count");
Assert.AreEqual (2, logger.TargetFinished, "TargetFinished count");
Assert.AreEqual (10, logger.TaskStarted, "TaskStarted count");
Assert.AreEqual (10, logger.TaskFinished, "TaskFinished count");
} catch (AssertionException) {
logger.DumpMessages ();
throw;
}
}
public void TestLazyLoad2 ()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<UsingTask
AssemblyFile='Test/resources/TestTasks.dll'
TaskName='Another.SameTask'
/>
<UsingTask
AssemblyFile='Test/resources/TestTasks.dll'
TaskName='Other.SameTask'
/>
<Target Name='1'>
<Other.SameTask>
<Output TaskParameter='OutputString' ItemName='I0'/>
</Other.SameTask>
<Another.SameTask>
<Output TaskParameter='OutputString' ItemName='I1'/>
</Another.SameTask>
<Message Text='I0: @(I0) I1: @(I1)'/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
project.LoadXml (documentString);
if (!project.Build ("1")) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
logger.CheckLoggedMessageHead ("I0: Other.SameTask I1: Another.SameTask", "A1");
}
public void TestBeforeAndAfterTargets ()
{
Engine engine;
Project project;
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" ToolsVersion=""4.0"">
<Target Name=""DefaultBeforeTarget1"" BeforeTargets=""Default"">
<Message Text=""Hello from DefaultBeforeTarget1""/>
</Target>
<Target Name=""DefaultBeforeTarget2"" BeforeTargets=""Default;Default;NonExistant"">
<Message Text=""Hello from DefaultBeforeTarget2""/>
</Target>
<Target Name=""DefaultAfterTarget"" AfterTargets=""Default ; Foo"">
<Message Text=""Hello from DefaultAfterTarget""/>
</Target>
<Target Name=""Default"" DependsOnTargets=""DefaultDependsOn"">
<Message Text=""Hello from Default""/>
</Target>
<Target Name=""DefaultDependsOn"">
<Message Text=""Hello from DefaultDependsOn""/>
</Target>
</Project>";
engine = new Engine ();
project = engine.CreateNewProject ();
project.LoadXml (projectString);
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
if (!project.Build ("Default")) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
logger.CheckLoggedMessageHead ("Hello from DefaultDependsOn", "A1");
logger.CheckLoggedMessageHead ("Hello from DefaultBeforeTarget1", "A1");
logger.CheckLoggedMessageHead ("Hello from DefaultBeforeTarget2", "A1");
logger.CheckLoggedMessageHead ("Hello from Default", "A1");
logger.CheckLoggedMessageHead ("Hello from DefaultAfterTarget", "A1");
Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected messages found");
//warnings for referencing unknown targets: NonExistant and Foo
Assert.AreEqual (2, logger.WarningsCount, "Expected warnings not raised");
}
public void TestLazyLoad3 ()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<UsingTask
AssemblyFile='Test/resources/TestTasks.dll'
TaskName='Another.SameTask'
Condition='false'
/>
<Target Name='1'>
<Another.SameTask />
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
project.LoadXml (documentString);
IEnumerator en = project.UsingTasks.GetEnumerator ();
en.MoveNext ();
UsingTask ut = (UsingTask) en.Current;
Assert.AreEqual ("Test/resources/TestTasks.dll", ut.AssemblyFile, "A1");
Assert.IsNull (ut.AssemblyName, "A2");
Assert.AreEqual ("false", ut.Condition, "A3");
Assert.AreEqual (false, ut.IsImported, "A4");
Assert.AreEqual ("Another.SameTask", ut.TaskName, "A5");
if (project.Build ("1")) {
logger.DumpMessages ();
Assert.Fail ("Build should've failed");
}
}
public bool BuildProject (Project project)
{
if (project == null)
throw new ArgumentException ("project");
return project.Build ();
}
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 bool BuildProject(Project project,
string[] targetNames,
IDictionary targetOutputs,
BuildSettings buildFlags)
{
if (project == null)
throw new ArgumentException ("project");
if (targetNames == null)
return false;
if ((buildFlags & BuildSettings.DoNotResetPreviouslyBuiltTargets) != BuildSettings.DoNotResetPreviouslyBuiltTargets)
builtTargetsOutputByName.Clear ();
if (defaultToolsVersion != null)
// it has been explicitly set, xbuild does this..
project.ToolsVersion = defaultToolsVersion;
return project.Build (targetNames, targetOutputs, buildFlags);
}
void CheckProjectBuild (Project project, string [] targetNames, bool result, string [] outputNames, string prefix)
{
IDictionary targetOutputs = new Hashtable ();
Assert.AreEqual (result, project.Build (targetNames, targetOutputs), prefix + "A1");
Assert.AreEqual (outputNames.Length, targetOutputs.Keys.Count, prefix + "A2");
foreach (string outputName in outputNames) {
Assert.IsTrue (targetOutputs.Contains (outputName), prefix + " A3: target " + outputName);
object o = targetOutputs [outputName];
Assert.IsTrue (typeof (ITaskItem []).IsAssignableFrom (o.GetType ()), prefix + " A4: target " + outputName);
ITaskItem [] items = (ITaskItem [])o;
Assert.AreEqual (0, items.Length, prefix + "A5: target " + outputName);
}
}
public void TestExecution2 ()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='1'>
<Error Text='Text' HelpKeyword='HelpKeyword' Code='Code' />
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
testLogger = new TestErrorLogger ();
engine.RegisterLogger (testLogger);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
project.Build ("1");
Assert.AreEqual (0, testLogger.CheckHead ("Text", "HelpKeyword", "Code"), "A1");
}
public Assembly CompileProject(string projectFileName)
{
Assembly existing;
if (Compilations.TryGetValue(Path.GetFullPath(projectFileName), out existing))
{
return(existing);
}
var project = new Microsoft.Build.BuildEngine.Project();
project.Load(projectFileName);
var projectName = Environment.NameTable.GetNameFor(project.EvaluatedProperties["AssemblyName"].Value);
var projectPath = project.FullFileName;
var compilerOptions = new SpecSharpOptions();
var assemblyReferences = new List <IAssemblyReference>();
var moduleReferences = new List <IModuleReference>();
var programSources = new List <SpecSharpSourceDocument>();
var assembly = new SpecSharpAssembly(projectName, projectPath, Environment, compilerOptions, assemblyReferences, moduleReferences, programSources);
var helper = new SpecSharpCompilationHelper(assembly.Compilation);
Compilations[Path.GetFullPath(projectFileName)] = assembly;
assemblyReferences.Add(Environment.LoadAssembly(Environment.CoreAssemblySymbolicIdentity));
project.Build("ResolveAssemblyReferences");
foreach (BuildItem item in project.GetEvaluatedItemsByName("ReferencePath"))
{
var assemblyName = new System.Reflection.AssemblyName(item.GetEvaluatedMetadata("FusionName"));
var name = Environment.NameTable.GetNameFor(assemblyName.Name);
var culture = assemblyName.CultureInfo != null ? assemblyName.CultureInfo.Name : "";
var version = assemblyName.Version == null ? new Version(0, 0) : assemblyName.Version;
var token = assemblyName.GetPublicKeyToken();
if (token == null)
{
token = new byte[0];
}
var location = item.FinalItemSpec;
var identity = new AssemblyIdentity(name, culture, version, token, location);
var reference = Environment.LoadAssembly(identity);
assemblyReferences.Add(reference);
}
foreach (BuildItem item in project.GetEvaluatedItemsByName("ProjectReference"))
{
var name = Environment.NameTable.GetNameFor(Path.GetFileNameWithoutExtension(item.FinalItemSpec));
var location = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(project.FullFileName), item.FinalItemSpec));
var reference = CompileProject(location);
assemblyReferences.Add(reference);
}
foreach (BuildItem item in project.GetEvaluatedItemsByName("Compile"))
{
var location = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(project.FullFileName), item.FinalItemSpec));
var name = Environment.NameTable.GetNameFor(location);
var programSource = new SpecSharpSourceDocument(helper, name, location, File.ReadAllText(location));
programSources.Add(programSource);
}
return(assembly);
}
