public void ToolExeIsFoundOnToolPath()
{
string shellName = NativeMethodsShared.IsWindows ? "cmd.exe" : "sh";
string copyName = NativeMethodsShared.IsWindows ? "xcopy.exe" : "cp";
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.FullToolName = shellName;
#if FEATURE_SPECIAL_FOLDERS
string systemPath = Environment.GetFolderPath(Environment.SpecialFolder.System);
#else
string systemPath = FileUtilities.GetFolderPath(FileUtilities.SpecialFolder.System);
#endif
t.ToolPath = systemPath;
t.Execute();
Assert.Equal(Path.Combine(systemPath, shellName), t.PathToToolUsed);
engine.AssertLogContains(shellName);
engine.Log = String.Empty;
t.ToolExe = copyName;
t.Execute();
Assert.Equal(Path.Combine(systemPath, copyName), t.PathToToolUsed);
engine.AssertLogContains(copyName);
engine.AssertLogDoesntContain(shellName);
}
}
public void ToolTaskCanChangeCanonicalErrorFormat()
{
string tempFile = FileUtilities.GetTemporaryFile();
File.WriteAllText(tempFile, @"
Main.cs(17,20): warning CS0168: The variable 'foo' is declared but never used.
BADTHINGHAPPENED: This is my custom error format that's not in canonical error format.
");
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
// The command we're giving is the command to spew the contents of the temp
// file we created above.
t.MockCommandLineCommands = "/C type \"" + tempFile + "\"";
t.Execute();
// The above command logged a canonical warning, as well as a custom error.
engine.AssertLogContains("CS0168");
engine.AssertLogContains("The variable 'foo' is declared but never used");
engine.AssertLogContains("BADTHINGHAPPENED");
engine.AssertLogContains("This is my custom error format");
Assert.Equal(1, engine.Warnings); // "Expected one warning in log."
Assert.Equal(1, engine.Errors); // "Expected one error in log."
}
File.Delete(tempFile);
}
public void ToolPathIsFoundWhenDirectoryExistsWithNameOfTool()
{
string toolName = NativeMethodsShared.IsWindows ? "cmd" : "sh";
string savedCurrentDirectory = Directory.GetCurrentDirectory();
try
{
using (var env = TestEnvironment.Create())
{
string tempDirectory = env.CreateFolder().FolderPath;
env.SetCurrentDirectory(tempDirectory);
env.SetEnvironmentVariable("PATH", $"{tempDirectory}{Path.PathSeparator}{Environment.GetEnvironmentVariable("PATH")}");
Directory.SetCurrentDirectory(tempDirectory);
string directoryNamedSameAsTool = Directory.CreateDirectory(Path.Combine(tempDirectory, toolName)).FullName;
MyTool task = new MyTool
{
BuildEngine = new MockEngine(),
FullToolName = toolName,
};
bool result = task.Execute();
Assert.NotEqual(directoryNamedSameAsTool, task.PathToToolUsed);
Assert.True(result);
}
}
finally
{
Directory.SetCurrentDirectory(savedCurrentDirectory);
}
}
public void ToolPathIsFoundWhenDirectoryExistsWithNameOfTool()
{
string toolName = NativeMethodsShared.IsWindows ? "cmd" : "sh";
string savedCurrentDirectory = Directory.GetCurrentDirectory();
string tempDirectory = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"))).FullName;
try
{
using (new Helpers.TemporaryEnvironment("PATH", $"{tempDirectory}{Path.PathSeparator}{Environment.GetEnvironmentVariable("PATH")}"))
{
Directory.SetCurrentDirectory(tempDirectory);
string directoryNamedSameAsTool = Directory.CreateDirectory(Path.Combine(tempDirectory, toolName)).FullName;
MyTool task = new MyTool
{
BuildEngine = new MockEngine(),
FullToolName = toolName,
};
bool result = task.Execute();
Assert.NotEqual(directoryNamedSameAsTool, task.PathToToolUsed);
Assert.True(result);
}
}
finally
{
Directory.SetCurrentDirectory(savedCurrentDirectory);
FileUtilities.DeleteDirectoryNoThrow(tempDirectory, recursive: true);
}
}
public void DoNotFormatTaskCommandOrMessage()
{
MyTool t = new MyTool();
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.MockCommandLineCommands = "/C echo hello world {"; // Unmatched curly would crash if they did
t.Execute();
engine.AssertLogContains("echo hello world {");
Assert.Equal(0, engine.Errors);
}
public void EnvironmentVariablesToToolTaskEqualsSign()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = new string[] { "a=b=c" };
bool result = task.Execute();
Assert.Equal(true, result);
Assert.Equal("b=c", task.StartInfo.EnvironmentVariables["a"]);
}
public void EnvironmentVariablesToToolTaskInvalid3()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = new string[] { "=a;b=c" };
bool result = task.Execute();
Assert.Equal(false, result);
Assert.Equal(false, task.ExecuteCalled);
}
public void EnvironmentVariablesToToolTaskInvalid3()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = new string[] { "=a;b=c" };
bool result = task.Execute();
result.ShouldBe(false);
task.ExecuteCalled.ShouldBe(false);
}
public void EnvironmentVariablesToToolTaskNotSet()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = null;
bool result = task.Execute();
Assert.Equal(true, result);
Assert.Equal(true, task.ExecuteCalled);
Assert.Equal(true, task.StartInfo.EnvironmentVariables["username"].Length > 0);
}
public void ToolExeIsFoundOnToolPath()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.FullToolName = "cmd.exe";
string systemPath = Environment.GetFolderPath(Environment.SpecialFolder.System);
t.ToolPath = systemPath;
t.Execute();
Assert.Equal(Path.Combine(systemPath, "cmd.exe"), t.PathToToolUsed);
engine.AssertLogContains("cmd.exe");
engine.Log = String.Empty;
t.ToolExe = "xcopy.exe";
t.Execute();
Assert.Equal(Path.Combine(systemPath, "xcopy.exe"), t.PathToToolUsed);
engine.AssertLogContains("xcopy.exe");
engine.AssertLogDoesntContain("cmd.exe");
}
}
public void VisualBasicLikeEscapedQuotesInCommandAreNotMadeForwardSlashes()
{
MyTool t = new MyTool();
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.MockCommandLineCommands = NativeMethodsShared.IsWindows
? "/C echo \"hello \\\"world\\\"\""
: "-c echo \"hello \\\"world\\\"\"";
t.Execute();
engine.AssertLogContains("echo \"hello \\\"world\\\"\"");
Assert.Equal(0, engine.Errors);
}
public void DoNotFormatTaskCommandOrMessage()
{
MyTool t = new MyTool();
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
// Unmatched curly would crash if they did
t.MockCommandLineCommands = NativeMethodsShared.IsWindows
? "/C echo hello world {"
: @"-c """"""echo hello world {""""""";
t.Execute();
engine.AssertLogContains("echo hello world {");
engine.Errors.ShouldBe(0);
}
public void Regress_Mutation_MissingExecutableIsLogged()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.ToolPath = NativeMethodsShared.IsWindows ? @"C:\MyAlternatePath" : "/MyAlternatePath";
t.Execute().ShouldBeFalse();
// There should be an error about invalid task location.
engine.AssertLogContains("MSB6004");
}
}
public void Regress_Mutation_UserSuppliedToolPathIsLogged()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.ToolPath = @"C:\MyAlternatePath";
t.Execute();
// The alternate path should be mentioned in the log.
engine.AssertLogContains("MyAlternatePath");
}
}
public void Regress_Mutation_MissingExecutableIsLogged()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.ToolPath = @"C:\MyAlternatePath";
Assert.False(t.Execute());
// There should be an error about invalid task location.
engine.AssertLogContains("MSB6004");
}
}
public void TaskNotFoundOnPath()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.FullToolName = "doesnotexist.exe";
Assert.False(t.Execute());
Assert.Equal(-1, t.ExitCode);
Assert.Equal(1, engine.Errors);
// Does not throw an exception
}
}
public void TaskFoundOnPath()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.FullToolName = "cmd.exe";
Assert.True(t.Execute());
Assert.Equal(0, t.ExitCode);
Assert.Equal(0, engine.Errors);
engine.AssertLogContains(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "cmd.exe"));
}
}
public void TaskNotFoundOnPath()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.FullToolName = "doesnotexist.exe";
t.Execute().ShouldBeFalse();
t.ExitCode.ShouldBe(-1);
engine.Errors.ShouldBe(1);
// Does not throw an exception
}
}
public void EnvironmentVariablesToToolTaskEqualsSign()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = new string[] { "a=b=c" };
bool result = task.Execute();
Assert.Equal(true, result);
#if FEATURE_PROCESSSTARTINFO_ENVIRONMENT
Assert.Equal("b=c", task.StartInfo.Environment["a"]);
#else
Assert.Equal("b=c", task.StartInfo.EnvironmentVariables["a"]);
#endif
}
public void DoNotErrorWhenTextSentToStandardError()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.MockCommandLineCommands = "/C Echo 'Who made you king anyways' 1>&2";
Assert.True(t.Execute());
engine.AssertLogDoesntContain("MSB");
engine.AssertLogContains("Who made you king anyways");
Assert.Equal(0, t.ExitCode);
Assert.Equal(0, engine.Errors);
}
}
public void ErrorWhenTextSentToStandardError()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.LogStandardErrorAsError = true;
t.MockCommandLineCommands = "/C Echo 'Who made you king anyways' 1>&2";
Assert.IsFalse(t.Execute());
engine.AssertLogDoesntContain("MSB3073");
engine.AssertLogContains("Who made you king anyways");
Assert.AreEqual(-1, t.ExitCode);
Assert.AreEqual(1, engine.Errors);
}
}
public void DoNotErrorWhenTextSentToStandardError()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.MockCommandLineCommands = NativeMethodsShared.IsWindows
? "/C Echo 'Who made you king anyways' 1>&2"
: @"-c """"""echo Who made you king anyways 1>&2""""""";
t.Execute().ShouldBeTrue();
engine.AssertLogDoesntContain("MSB");
engine.AssertLogContains("Who made you king anyways");
t.ExitCode.ShouldBe(0);
engine.Errors.ShouldBe(0);
}
}
public void EnvironmentVariablesToToolTaskNotSet()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = null;
bool result = task.Execute();
Assert.Equal(true, result);
Assert.Equal(true, task.ExecuteCalled);
Assert.Equal(
true,
#if FEATURE_PROCESSSTARTINFO_ENVIRONMENT
task.StartInfo.Environment["PATH"].Length > 0);
#else
task.StartInfo.EnvironmentVariables["PATH"].Length > 0);
#endif
}
public void HandleExecutionErrorsWhenToolDoesntLogError()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.MockCommandLineCommands = "/C garbagegarbagegarbagegarbage.exe";
Assert.False(t.Execute());
Assert.Equal(1, t.ExitCode); // cmd.exe error code is 1
// We just tried to run "cmd.exe /C garbagegarbagegarbagegarbage.exe". This should fail,
// but since "cmd.exe" doesn't log its errors in canonical format, no errors got
// logged by the tool itself. Therefore, ToolTask's default implementation of
// HandleTaskExecutionErrors should have logged error MSB6006.
engine.AssertLogContains("MSB6006");
}
}
public void HandleExecutionErrorsWhenToolLogsError()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.MockCommandLineCommands = "/C echo Main.cs(17,20): error CS0168: The variable 'foo' is declared but never used";
Assert.False(t.Execute());
// The above command logged a canonical error message. Therefore ToolTask should
// not log its own error beyond that.
engine.AssertLogDoesntContain("MSB6006");
engine.AssertLogContains("CS0168");
engine.AssertLogContains("The variable 'foo' is declared but never used");
Assert.Equal(-1, t.ExitCode);
Assert.Equal(1, engine.Errors);
}
}
public void DoNotErrorWhenTextSentToStandardOutput()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.LogStandardErrorAsError = true;
t.MockCommandLineCommands = NativeMethodsShared.IsWindows
? "/C Echo 'Who made you king anyways'"
: @"-c """"""echo Who made you king anyways""""""";
Assert.True(t.Execute());
engine.AssertLogDoesntContain("MSB");
engine.AssertLogContains("Who made you king anyways");
Assert.Equal(0, t.ExitCode);
Assert.Equal(0, engine.Errors);
}
}
public void EnvironmentVariablesToToolTask()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
string userVarName = NativeMethodsShared.IsWindows ? "username" : "user";
task.EnvironmentVariables = new string[] { "a=b", "c=d", userVarName + "=x" /* built-in */, "path=" /* blank value */ };
bool result = task.Execute();
Assert.Equal(true, result);
Assert.Equal(true, task.ExecuteCalled);
ProcessStartInfo startInfo = task.StartInfo;
#if FEATURE_PROCESSSTARTINFO_ENVIRONMENT
Assert.Equal("b", startInfo.Environment["a"]);
Assert.Equal("d", startInfo.Environment["c"]);
Assert.Equal("x", startInfo.Environment[userVarName]);
Assert.Equal(String.Empty, startInfo.Environment["path"]);
#else
Assert.Equal("b", startInfo.EnvironmentVariables["a"]);
Assert.Equal("d", startInfo.EnvironmentVariables["c"]);
Assert.Equal("x", startInfo.EnvironmentVariables[userVarName]);
Assert.Equal(String.Empty, startInfo.EnvironmentVariables["path"]);
#endif
if (NativeMethodsShared.IsWindows)
{
Assert.Equal(
#if FEATURE_SPECIAL_FOLDERS
Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles),
#else
FileUtilities.GetFolderPath(FileUtilities.SpecialFolder.ProgramFiles),
#endif
#if FEATURE_PROCESSSTARTINFO_ENVIRONMENT
startInfo.Environment["programfiles"],
#else
startInfo.EnvironmentVariables["programfiles"],
#endif
true);
}
}
public void EnvironmentVariablesToToolTask()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = new string[] { "a=b", "c=d", "username=x" /* built-in */, "path=" /* blank value */ };
bool result = task.Execute();
Assert.Equal(true, result);
Assert.Equal(true, task.ExecuteCalled);
ProcessStartInfo startInfo = task.StartInfo;
Assert.Equal("b", startInfo.EnvironmentVariables["a"]);
Assert.Equal("d", startInfo.EnvironmentVariables["c"]);
Assert.Equal("x", startInfo.EnvironmentVariables["username"]);
Assert.Equal(String.Empty, startInfo.EnvironmentVariables["path"]);
Assert.True(String.Equals(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), startInfo.EnvironmentVariables["programfiles"], StringComparison.OrdinalIgnoreCase));
}
public void Regress_Mutation_WarnIfCommandLineTooLong()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
// "cmd.exe" croaks big-time when given a very long command-line. It pops up a message box on
// Windows XP. We can't have that! So use "attrib.exe" for this exercise instead.
t.FullToolName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "attrib.exe");
t.MockCommandLineCommands = new String('x', 32001);
// It's only a warning, we still succeed
Assert.True(t.Execute());
Assert.Equal(0, t.ExitCode);
// There should be a warning about the command-line being too long.
engine.AssertLogContains("MSB6002");
}
}
public void GetProcessStartInfoCanOverrideEnvironmentVariables()
{
MyTool task = new MyTool();
#if FEATURE_PROCESSSTARTINFO_ENVIRONMENT
task.DoProcessStartInfoMutation = (p) => p.Environment.Remove("a");
#else
task.DoProcessStartInfoMutation = (p) => p.EnvironmentVariables.Remove("a");
#endif
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = new string[] { "a=b" };
bool result = task.Execute();
Assert.Equal(true, result);
#if FEATURE_PROCESSSTARTINFO_ENVIRONMENT
Assert.Equal(false, task.StartInfo.Environment.ContainsKey("a"));
#else
Assert.Equal(false, task.StartInfo.EnvironmentVariables.ContainsKey("a"));
#endif
}
public void ToolTaskCanChangeCanonicalErrorFormat()
{
string tempFile = FileUtilities.GetTemporaryFile();
File.WriteAllText(tempFile, @"
Main.cs(17,20): warning CS0168: The variable 'foo' is declared but never used.
BADTHINGHAPPENED: This is my custom error format that's not in canonical error format.
");
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
// The command we're giving is the command to spew the contents of the temp
// file we created above.
t.MockCommandLineCommands = "/C type \"" + tempFile + "\"";
t.Execute();
// The above command logged a canonical warning, as well as a custom error.
engine.AssertLogContains("CS0168");
engine.AssertLogContains("The variable 'foo' is declared but never used");
engine.AssertLogContains("BADTHINGHAPPENED");
engine.AssertLogContains("This is my custom error format");
Assert.AreEqual(1, engine.Warnings, "Expected one warning in log.");
Assert.AreEqual(1, engine.Errors, "Expected one error in log.");
}
File.Delete(tempFile);
}
public void Regress_Mutation_WarnIfCommandLineTooLong()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
// "cmd.exe" croaks big-time when given a very long command-line. It pops up a message box on
// Windows XP. We can't have that! So use "attrib.exe" for this exercise instead.
t.FullToolName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "attrib.exe");
t.MockCommandLineCommands = new String('x', 32001);
// It's only a warning, we still succeed
Assert.IsTrue(t.Execute());
Assert.AreEqual(0, t.ExitCode);
// There should be a warning about the command-line being too long.
engine.AssertLogContains("MSB6002");
}
}
public void TaskNotFoundOnPath()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.FullToolName = "doesnotexist.exe";
Assert.IsFalse(t.Execute());
Assert.AreEqual(-1, t.ExitCode);
Assert.AreEqual(1, engine.Errors);
// Does not throw an exception
}
}
public void EnvironmentVariablesToToolTaskInvalid3()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = new string[] { "=a;b=c" };
bool result = task.Execute();
Assert.AreEqual(false, result);
Assert.AreEqual(false, task.ExecuteCalled);
}
public void HandleExecutionErrorsWhenToolDoesntLogError()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.MockCommandLineCommands = "/C garbagegarbagegarbagegarbage.exe";
Assert.IsFalse(t.Execute());
Assert.AreEqual(1, t.ExitCode); // cmd.exe error code is 1
// We just tried to run "cmd.exe /C garbagegarbagegarbagegarbage.exe". This should fail,
// but since "cmd.exe" doesn't log its errors in canonical format, no errors got
// logged by the tool itself. Therefore, ToolTask's default implementation of
// HandleTaskExecutionErrors should have logged error MSB6006.
engine.AssertLogContains("MSB6006");
}
}
public void ToolExeIsFoundOnToolPath()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.FullToolName = "cmd.exe";
string systemPath = Environment.GetFolderPath(Environment.SpecialFolder.System);
t.ToolPath = systemPath;
t.Execute();
Assert.AreEqual(Path.Combine(systemPath, "cmd.exe"), t.PathToToolUsed);
engine.AssertLogContains("cmd.exe");
engine.Log = String.Empty;
t.ToolExe = "xcopy.exe";
t.Execute();
Assert.AreEqual(Path.Combine(systemPath, "xcopy.exe"), t.PathToToolUsed);
engine.AssertLogContains("xcopy.exe");
engine.AssertLogDoesntContain("cmd.exe");
}
}
public void EnvironmentVariablesToToolTaskNotSet()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = null;
bool result = task.Execute();
Assert.AreEqual(true, result);
Assert.AreEqual(true, task.ExecuteCalled);
Assert.AreEqual(true, task.StartInfo.EnvironmentVariables["username"].Length > 0);
}
public void HandleExecutionErrorsWhenToolLogsError()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.MockCommandLineCommands = "/C echo Main.cs(17,20): error CS0168: The variable 'foo' is declared but never used";
Assert.IsFalse(t.Execute());
// The above command logged a canonical error message. Therefore ToolTask should
// not log its own error beyond that.
engine.AssertLogDoesntContain("MSB6006");
engine.AssertLogContains("CS0168");
engine.AssertLogContains("The variable 'foo' is declared but never used");
Assert.AreEqual(-1, t.ExitCode);
Assert.AreEqual(1, engine.Errors);
}
}
public void OverrideStdOutImportanceToHigh()
{
string tempFile = FileUtilities.GetTemporaryFile();
File.WriteAllText(tempFile, @"hello world");
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
engine.MinimumMessageImportance = MessageImportance.High;
t.BuildEngine = engine;
t.FullToolName = "find.exe";
t.MockCommandLineCommands = "\"hello\" \"" + tempFile + "\"";
t.StandardOutputImportance = "High";
Assert.IsTrue(t.Execute());
Assert.AreEqual(0, t.ExitCode);
Assert.AreEqual(0, engine.Errors);
engine.AssertLogContains("hello world");
}
File.Delete(tempFile);
}
public void TaskFoundOnPath()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.FullToolName = "cmd.exe";
Assert.IsTrue(t.Execute());
Assert.AreEqual(0, t.ExitCode);
Assert.AreEqual(0, engine.Errors);
engine.AssertLogContains(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "cmd.exe"));
}
}
public void EnvironmentVariablesToToolTaskEqualsSign()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = new string[] { "a=b=c" };
bool result = task.Execute();
Assert.AreEqual(true, result);
Assert.AreEqual("b=c", task.StartInfo.EnvironmentVariables["a"]);
}
public void Regress_Mutation_MissingExecutableIsLogged()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.ToolPath = @"C:\MyAlternatePath";
Assert.IsFalse(t.Execute());
// There should be an error about invalid task location.
engine.AssertLogContains("MSB6004");
}
}
public void EnvironmentVariablesToToolTask()
{
MyTool task = new MyTool();
task.BuildEngine = new MockEngine();
task.EnvironmentVariables = new string[] { "a=b", "c=d", "username=x" /* built-in */, "path=" /* blank value */};
bool result = task.Execute();
Assert.AreEqual(true, result);
Assert.AreEqual(true, task.ExecuteCalled);
ProcessStartInfo startInfo = task.StartInfo;
Assert.AreEqual("b", startInfo.EnvironmentVariables["a"]);
Assert.AreEqual("d", startInfo.EnvironmentVariables["c"]);
Assert.AreEqual("x", startInfo.EnvironmentVariables["username"]);
Assert.AreEqual(String.Empty, startInfo.EnvironmentVariables["path"]);
Assert.IsTrue(String.Equals(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), startInfo.EnvironmentVariables["programfiles"], StringComparison.OrdinalIgnoreCase));
}
public void Regress_Mutation_UserSuppliedToolPathIsLogged()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.ToolPath = @"C:\MyAlternatePath";
t.Execute();
// The alternate path should be mentioned in the log.
engine.AssertLogContains("MyAlternatePath");
}
}
public void DoNotFormatTaskCommandOrMessage()
{
MyTool t = new MyTool();
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.MockCommandLineCommands = "/C echo hello world {"; // Unmatched curly would crash if they did
t.Execute();
engine.AssertLogContains("echo hello world {");
Assert.AreEqual(0, engine.Errors);
}
public void DoNotErrorWhenTextSentToStandardOutput()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.LogStandardErrorAsError = true;
t.MockCommandLineCommands = "/C Echo 'Who made you king anyways'";
Assert.True(t.Execute());
engine.AssertLogDoesntContain("MSB");
engine.AssertLogContains("Who made you king anyways");
Assert.Equal(0, t.ExitCode);
Assert.Equal(0, engine.Errors);
}
}
public void ErrorWhenTextSentToStandardError()
{
using (MyTool t = new MyTool())
{
MockEngine engine = new MockEngine();
t.BuildEngine = engine;
t.LogStandardErrorAsError = true;
t.MockCommandLineCommands = "/C Echo 'Who made you king anyways' 1>&2";
Assert.IsFalse(t.Execute());
engine.AssertLogDoesntContain("MSB3073");
engine.AssertLogContains("Who made you king anyways");
Assert.AreEqual(-1, t.ExitCode);
Assert.AreEqual(1, engine.Errors);
}
}