Imported Upstream version 3.12.0

Former-commit-id: cf92446697332992ec36726e78eb8703e1f259d7

mcs/class/Microsoft.Build.Utilities/Microsoft.Build.Utilities/ToolTask.cs

@@ -1,12 +1,14 @@
 //
 // ToolTask.cs: Base class for command line tool tasks. 
 //
-// Author:
+// Authors:
 //   Marek Sieradzki (marek.sieradzki@gmail.com)
 //   Ankit Jain (jankit@novell.com)
+//   Marek Safar (marek.safar@gmail.com)
 //
 // (C) 2005 Marek Sieradzki
 // Copyright 2009 Novell, Inc (http://www.novell.com)
+// Copyright 2014 Xamarin Inc
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
@@ -90,12 +92,45 @@ namespace Microsoft.Build.Utilities
 			return true;
 		}
 
+		string CreateToolPath ()
+		{
+			string tp;
+			if (string.IsNullOrEmpty (ToolPath)) {
+				tp = GenerateFullPathToTool ();
+				if (string.IsNullOrEmpty (tp))
+					return null;
+
+				//
+				// GenerateFullPathToTool can return path including tool name
+				//
+				if (string.IsNullOrEmpty (ToolExe))
+					return tp;
+
+				tp = Path.GetDirectoryName (tp);
+			} else {
+				tp = ToolPath;
+			}
+
+			var	path = Path.Combine (tp, ToolExe);
+			if (!File.Exists (path)) {
+				if (Log != null)
+					Log.LogError ("Tool executable '{0}' could not be found", path);
+				return null;
+			}
+
+			return path;
+		}
+
 		public override bool Execute ()
 		{
 			if (SkipTaskExecution ())
 				return true;
 
-			exitCode = ExecuteTool (GenerateFullPathToTool (), GenerateResponseFileCommands (),
+			var tool_path = CreateToolPath ();
+			if (tool_path == null)
+				return false;
+
+			exitCode = ExecuteTool (tool_path, GenerateResponseFileCommands (),
 				GenerateCommandLineCommands ());
 
 			// HandleTaskExecutionErrors is called only if exitCode != 0
@@ -289,14 +324,14 @@ namespace Microsoft.Build.Utilities
 
 		protected virtual string GenerateCommandLineCommands ()
 		{
-			return null;
+			return "";
 		}
 
 		protected abstract string GenerateFullPathToTool ();
 
 		protected virtual string GenerateResponseFileCommands ()
 		{
-			return null;
+			return "";
 		}
 
 		protected virtual string GetResponseFileSwitch (string responseFilePath)

mcs/class/Microsoft.Build.Utilities/Test/Microsoft.Build.Utilities/ToolTaskTest.cs

@@ -26,6 +26,7 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
@@ -424,6 +425,53 @@ namespace MonoTests.Microsoft.Build.Utilities {
 			Assert.AreEqual (a.ToolPath, "Bar", "#5");
 			a.ToolPath = "";
 			Assert.AreEqual (a.ToolPath, "", "#6");
+
+			a.Execute ();
+		}
+
+		[Test]
+		public void Execute_1 ()
+		{
+			var t = new TestExecuteToolTask ();
+			t.OnExecuteTool = delegate { Assert.Fail ("#1"); };
+			t.BuildEngine = new MockBuildEngine ();
+			Assert.IsFalse (t.Execute (), "result");
+		}
+
+		[Test]
+		public void Execute_2 ()
+		{
+			var t = new TestExecuteToolTask ();
+			t.BuildEngine = new MockBuildEngine ();
+			t.ToolPath = Directory.GetCurrentDirectory ();
+			t.ToolExe = "Makefile";
+
+			t.OnExecuteTool = (pathToTool, responseFileCommands, commandLineCommands) => {
+				Assert.AreEqual (Path.Combine (Directory.GetCurrentDirectory (), "Makefile"), pathToTool, "#1");
+				Assert.AreEqual ("", responseFileCommands, "#2");
+				Assert.AreEqual ("", commandLineCommands, "#3");
+
+			};
+
+			Assert.IsTrue (t.Execute (), "result");
+		}
+
+		[Test]
+		public void Execute_3 ()
+		{
+			var t = new TestExecuteToolTask ();
+			t.FullPathToTool = "fpt";
+			t.BuildEngine = new MockBuildEngine ();
+			t.ToolExe = "Makefile.mk";
+
+			t.OnExecuteTool = (pathToTool, responseFileCommands, commandLineCommands) => {
+				Assert.AreEqual ("Makefile.mk", pathToTool, "#1");
+				Assert.AreEqual ("", responseFileCommands, "#2");
+				Assert.AreEqual ("", commandLineCommands, "#3");
+
+			};
+
+			Assert.IsFalse (t.Execute (), "result");
 		}
 	}
 
@@ -548,9 +596,86 @@ namespace MonoTests.Microsoft.Build.Utilities {
 		}
 
 		protected override string GenerateFullPathToTool ()
+		{
+			return "";
+		}
+	}
+
+	class MockBuildEngine : IBuildEngine
+	{
+		public int ColumnNumberOfTaskNode {
+			get {
+				return 0;
+			}
+		}
+
+		public bool ContinueOnError {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+
+		public int LineNumberOfTaskNode {
+			get {
+				return 0;
+			}
+		}
+
+		public string ProjectFileOfTaskNode {
+			get {
+				return "ProjectFileOfTaskNode";
+			}
+		}
+
+		public bool BuildProjectFile (string projectFileName, string[] targetNames, IDictionary globalProperties, IDictionary targetOutputs)
 		{
 			throw new NotImplementedException ();
 		}
+
+		public void LogCustomEvent (CustomBuildEventArgs e)
+		{
+		}
+
+		public void LogErrorEvent (BuildErrorEventArgs e)
+		{
+			Console.WriteLine (e.Message);
+		}
+
+		public void LogMessageEvent (BuildMessageEventArgs e)
+		{
+		}
+
+		public void LogWarningEvent (BuildWarningEventArgs e)
+		{
+		}
+	}
+
+	class TestExecuteToolTask : ToolTask
+	{
+		public Action<string, string, string> OnExecuteTool;
+		public string FullPathToTool;
+
+		protected override string ToolName {
+			get { return "TestTool.exe"; }
+		}
+
+		protected override bool CallHostObjectToExecute ()
+		{
+			return base.CallHostObjectToExecute ();
+		}
+
+		protected override string GenerateFullPathToTool ()
+		{
+			return FullPathToTool;
+		}
+
+		protected override int ExecuteTool (string pathToTool, string responseFileCommands, string commandLineCommands)
+		{
+			if (OnExecuteTool != null)
+				OnExecuteTool (pathToTool, responseFileCommands, commandLineCommands);
+
+			return 0;
+		}
 	}
 }