public void TestCmdScript()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.Cmd, "@ECHO From CMD.exe"))
{
StringWriter sw = new StringWriter();
runner.OutputReceived += delegate(object o, ProcessOutputEventArgs e) { sw.WriteLine(e.Data); };
Assert.AreEqual(0, runner.Run());
Assert.AreEqual("From CMD.exe", sw.ToString().Trim());
}
}
public void TestCSharpScript()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.CSharp, "class Program { static void Main() { System.Console.WriteLine(\"From C#\"); } }"))
{
StringWriter sw = new StringWriter();
runner.OutputReceived += delegate(object o, ProcessOutputEventArgs e) { sw.WriteLine(e.Data); };
Assert.AreEqual(0, runner.Run());
Assert.AreEqual("From C#", sw.ToString().Trim());
}
}
public void TestScriptInfoExe()
{
using (TempFile file = TempFile.FromExtension(".exe"))
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.Exe, file.TempPath))
{
Assert.AreEqual(ScriptEngine.Language.Exe, runner.ScriptEngine.ScriptType);
Assert.AreEqual(file.TempPath, runner.ScriptEngine.Executable);
Assert.IsFalse(File.Exists(runner.ScriptFile));
}
}
public void TestScriptInfo()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.Cmd, "@ECHO From CMD.exe"))
{
Assert.AreEqual(ScriptEngine.Language.Cmd, runner.ScriptEngine.ScriptType);
Assert.IsTrue(File.Exists(runner.ScriptFile));
Assert.AreEqual("@ECHO From CMD.exe", File.ReadAllText(runner.ScriptFile));
Assert.AreEqual("/C " + runner.ScriptFile, String.Join(" ", runner.ScriptArguments));
}
}
public void TestWorkingDir()
{
using (TempDirectory dir = new TempDirectory())
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.Cmd, "@ECHO %cd%"))
{
string output = String.Empty;
runner.OutputReceived += delegate(object o, ProcessOutputEventArgs e) { output += e.Data; };
Assert.AreNotEqual(dir.TempPath, runner.WorkingDirectory);
runner.WorkingDirectory = dir.TempPath;
Assert.AreEqual(dir.TempPath, runner.WorkingDirectory);
runner.Run();
Assert.AreEqual(dir.TempPath.TrimEnd('\\', '/'), output.TrimEnd('\\', '/'));
}
}
public void Generate(IGeneratorArguments input)
{
Encoding encoding;
//auto-convert input encoding to the correct type
if (_config.InputEncoding != FileEncoding.Default)
{
encoding = _config.InputEncoding == FileEncoding.Ascii ? Encoding.ASCII : Encoding.UTF8;
using (var r = new StreamReader(input.InputPath, detectEncodingFromByteOrderMarks: true))
{
if (encoding.EncodingName != r.CurrentEncoding.EncodingName)
{
string text = r.ReadToEnd();
r.Dispose();
File.WriteAllText(input.InputPath, text, encoding);
}
}
}
encoding = _config.OutputEncoding == FileEncoding.Ascii ? Encoding.ASCII : Encoding.UTF8;
//Couple of assertions about PowerShell
if (_config.Script.Type == ScriptEngine.Language.PowerShell &&
(_config.StandardInput.Redirect || _config.Arguments.Length > 0))
throw new ApplicationException(
@"Currently PowerShell integration does not support input streams or arguments.
Primarily this is due to circumventing the script-signing requirements. By
using the '-Command -' argument we avoid signing or setting ExecutionPolicy.");
using (DebuggingOutput debug = new DebuggingOutput(_config.Debug, input.WriteLine))
{
debug.WriteLine("ConfigDir = {0}", _config.BaseDirectory);
input.ConfigDir = _config.BaseDirectory;
//Inject arguments into the script
string script = input.ReplaceVariables(Check.NotNull(_config.Script).Text.Trim());
if (!String.IsNullOrEmpty(_config.Script.Include))
script = File.ReadAllText(CreateFullPath(_config.Script.Include));
if (_config.Script.Type == ScriptEngine.Language.Exe)
script = CreateFullPath(script);
StringWriter swOutput = new StringWriter();
List<string> arguments = new List<string>();
foreach (GeneratorArgument arg in _config.Arguments)
arguments.Add(input.ReplaceVariables(arg.Text ?? String.Empty));
debug.WriteLine("Prepared Script:{0}{1}{0}{2}{0}{1}",
Environment.NewLine,
"---------------------------------------------",
script
);
using (ScriptRunner scriptEngine = new ScriptRunner(_config.Script.Type, script))
{
IRunner runner = scriptEngine;
if (input.AllowAppDomains && _config.Script.InvokeAssembly)
{
runner = AssemblyRunnerCache.Fetch(scriptEngine.ScriptEngine.Executable);
arguments.InsertRange(0, scriptEngine.ScriptArguments);
}
runner.WorkingDirectory = _config.BaseDirectory;
string lastErrorMessage = null;
ProcessOutputEventHandler handler =
delegate(object o, ProcessOutputEventArgs args)
{
if (args.Error)
input.WriteLine(lastErrorMessage = args.Data);
else if (_config.StandardOut != null)
{
debug.WriteLine("std::out: {0}", args.Data);
swOutput.WriteLine(args.Data);
}
else
input.WriteLine(args.Data);
};
int exitCode = -1;
debug.WriteLine("Executing {0} {1}", runner, ArgumentList.EscapeArguments(arguments.ToArray()));
try
{
runner.OutputReceived += handler;
if (_config.StandardInput.Redirect)
exitCode = runner.Run(new StringReader(File.ReadAllText(input.InputPath)), arguments.ToArray());
else exitCode = runner.Run(arguments.ToArray());
}
finally
{
debug.WriteLine("Exited = {0}", exitCode);
runner.OutputReceived -= handler;
}
if (_config.StandardOut != null)
{
string target = Path.ChangeExtension(input.InputPath, _config.StandardOut.Extension);
using (TempFile file = TempFile.FromExtension(_config.StandardOut.Extension))
{
File.WriteAllText(file.TempPath, swOutput.ToString(), encoding);
File.Copy(file.TempPath, target, true);
input.AddOutputFile(target);
}
}
if (exitCode != 0)
{
string message = "The script returned a non-zero result: " + exitCode;
input.WriteLine(message);
throw new ApplicationException(String.IsNullOrEmpty(lastErrorMessage) ? message : lastErrorMessage);
}
}
EnumOutputFiles(input, input.AddOutputFile);
}
}
public void TestJScriptScript()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.JScript, @"WScript.StdOut.WriteLine(WScript.Arguments(0));"))
{
StringWriter sw = new StringWriter();
runner.OutputReceived += delegate(object o, ProcessOutputEventArgs e) { sw.WriteLine(e.Data); };
runner.Start("From JScript");
runner.WaitForExit();
Assert.AreEqual(0, runner.ExitCode);
Assert.AreEqual("From JScript", sw.ToString().Trim());
}
}
public void TestExeScript()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.Exe, @"cmd.exe"))
{
StringWriter sw = new StringWriter();
runner.OutputReceived += delegate(object o, ProcessOutputEventArgs e) { sw.WriteLine(e.Data); };
Assert.AreEqual(0, runner.Run("/c", "@echo From EXE"));
Assert.AreEqual("From EXE", sw.ToString().Trim());
}
}
public void TestCSharpKilling()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.CSharp, "class Program { static void Main() { System.Threading.Thread.Sleep(System.TimeSpan.FromHours(1)); } }"))
{
ManualResetEvent mre = new ManualResetEvent(false);
runner.ProcessExited += delegate(object o, ProcessExitedEventArgs e) { mre.Set(); };
runner.Start();
Assert.IsTrue(runner.IsRunning);
Assert.IsFalse(runner.WaitForExit(TimeSpan.Zero));
runner.Kill();
Assert.IsTrue(mre.WaitOne(0, false));
Assert.IsFalse(runner.IsRunning);
Assert.IsTrue(runner.WaitForExit(TimeSpan.Zero));
Assert.AreNotEqual(0, runner.ExitCode);
}
}
public void TestRemoveExitedEvent()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.Cmd, "@ECHO From CMD.exe"))
{
ManualResetEvent mre = new ManualResetEvent(false);
ProcessExitedEventHandler h = delegate(object o, ProcessExitedEventArgs e) { mre.Set(); };
runner.ProcessExited += h;
runner.ProcessExited -= h;
Assert.AreEqual(0, runner.Run());
Assert.IsFalse(mre.WaitOne(250, false));
}
}
public void TestToString()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.Exe, @"cmd.exe"))
Assert.AreEqual(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "cmd.exe"), runner.ToString().Trim());
}
public void TestVbScriptScript()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.JScript, "WScript.StdOut.WriteLine(\"From VBScript\")"))
{
StringWriter sw = new StringWriter();
runner.OutputReceived += delegate(object o, ProcessOutputEventArgs e) { sw.WriteLine(e.Data); };
Assert.AreEqual(0, runner.Run());
Assert.AreEqual("From VBScript", sw.ToString().Trim());
}
}
public void TestVbNetScript()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.VBNet,
@"Module Module1
Sub Main()
System.Console.WriteLine(""From VB.Net"")
End Sub
End Module
"))
{
StringWriter sw = new StringWriter();
runner.OutputReceived += delegate(object o, ProcessOutputEventArgs e) { sw.WriteLine(e.Data); };
Assert.AreEqual(0, runner.Run());
Assert.AreEqual("From VB.Net", sw.ToString().Trim());
}
}
public void TestPowerShellScript()
{
using (ScriptRunner runner = new ScriptRunner(ScriptEngine.Language.PowerShell, "ECHO From_PowerShell"))
{
StringWriter sw = new StringWriter();
runner.OutputReceived += delegate(object o, ProcessOutputEventArgs e) { sw.WriteLine(e.Data); };
runner.Start();
runner.WaitForExit();
Assert.AreEqual(0, runner.ExitCode);
Assert.AreEqual("From_PowerShell", sw.ToString().Trim());
}
}
