using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Diagnostics;
|
using System.IO;
|
using System.Linq;
|
using System.Text;
|
using System.Threading;
|
using OpenTap.Cli;
|
|
namespace OpenTap.Engine.UnitTests.TestTestSteps
|
{
|
[Display("user-input", "Used to verify user-input implementations", Group: "test")]
|
public class UserInputTestAction : ICliAction
|
{
|
public class RequestObject
|
{
|
[Submit] public string Answer { get; set; }
|
}
|
|
[CommandLineArgument("answers", ShortName = "a", Description = "The answers that the caller is intending to give.")]
|
public string[] ExpectedAnswers { get; set; }
|
|
private static TraceSource log = Log.CreateSource(nameof(UserInputTestAction));
|
|
public static string DescribeBytes(IEnumerable<char> i)
|
{
|
var s = i.ToArray();
|
if (s.Length == 0) return "[]";
|
|
var sb = new StringBuilder();
|
sb.Append('[');
|
foreach (var ch in s)
|
{
|
sb.Append(string.Format("0x{0:X}", (int)ch));
|
sb.Append(", ");
|
}
|
sb.Remove(sb.Length - 2, 2);
|
sb.Append(']');
|
return sb.ToString();
|
}
|
|
public int Execute(CancellationToken cancellationToken)
|
{
|
try
|
{
|
for (int i = 0; i < ExpectedAnswers.Length; i++)
|
{
|
var r = new RequestObject();
|
log.Info($"Checking input {i + 1} of {ExpectedAnswers.Length} ({ExpectedAnswers[i]})");
|
UserInput.Request(r);
|
var exp = DescribeBytes(ExpectedAnswers[i]);
|
var act = DescribeBytes(r.Answer);
|
log.Info($"Expected: {exp}");
|
log.Info($" Actual: {act}");
|
if (r.Answer.Equals(ExpectedAnswers[i], StringComparison.InvariantCulture) == false)
|
{
|
log.Error($"Input {i + 1} did not match the expected input:");
|
log.Error($"Expected '{ExpectedAnswers[i]}', got '{r.Answer}'");
|
return 3;
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
log.Error($"Error while reading input: {ex.Message}");
|
log.Debug(ex);
|
}
|
|
return 0;
|
}
|
}
|
|
[Display("Piping Process Step", "A run process step with support for piping", "Tests")]
|
public class PipingProcessStep : TestStep
|
{
|
[Display("Application", Order: -2.5,
|
Description:
|
"The path to the program. It should contain either a relative path to OpenTAP installation folder or an absolute path to the program.")]
|
[FilePath(FilePathAttribute.BehaviorChoice.Open, "exe")]
|
public string Application { get; set; } = "";
|
|
[Display("Command Line Arguments", Order: -2.4, Description: "The arguments passed to the program.")]
|
[DefaultValue("")]
|
public string Arguments { get; set; } = "";
|
|
[Display("Expected Exit Code", "The expected exit code of the process.")]
|
public int ExpectedExitCode { get; set; } = 0;
|
|
[Display("Write Speed", "How fast should the input be written to the process stream. Measured in number of milliseconds between writes")]
|
[Unit("ms")]
|
public int WriteSpeed { get; set; } = 100;
|
|
[Layout(LayoutMode.Normal, 2, maxRowHeight: 5)]
|
[Display("Pipe Data", "The data that should be written to the process' input stream.")]
|
public string StdIn { get; set; } = "";
|
|
public enum WriteMode
|
{
|
WriteLines,
|
WriteChars,
|
WriteAll,
|
}
|
|
[Display("Write Mode", "How should the data be written to the pipe?")]
|
public WriteMode Mode { get; set; }
|
|
public override void Run()
|
{
|
using var process = new Process
|
{
|
StartInfo =
|
{
|
FileName = Application,
|
Arguments = Arguments,
|
WorkingDirectory = Directory.GetCurrentDirectory(),
|
UseShellExecute = false,
|
RedirectStandardError = true,
|
RedirectStandardInput = true,
|
RedirectStandardOutput = true,
|
CreateNoWindow = true,
|
}
|
};
|
|
Log.Info($"Starting process '{Application}' with arguments '{Arguments}'.");
|
|
if (!process.Start())
|
{
|
Log.Error("Process failed to start.");
|
UpgradeVerdict(Verdict.Error);
|
return;
|
}
|
|
process.OutputDataReceived += (sender, args) =>
|
{
|
if (args.Data == null) return;
|
Log.Info(args.Data);
|
};
|
process.ErrorDataReceived += (sender, args) =>
|
{
|
if (args.Data == null) return;
|
Log.Error(args.Data);
|
};
|
process.BeginOutputReadLine();
|
process.BeginErrorReadLine();
|
process.StandardInput.AutoFlush = true;
|
|
Log.Info($"Writing payload to process: {UserInputTestAction.DescribeBytes(StdIn)}");
|
|
try
|
{
|
var w = process.StandardInput;
|
switch (Mode)
|
{
|
case WriteMode.WriteAll:
|
w.Write(StdIn);
|
break;
|
case WriteMode.WriteLines:
|
foreach (var line in StdIn.Trim().Split('\n'))
|
{
|
if (WriteSpeed > 0)
|
TapThread.Sleep(WriteSpeed);
|
if (process.HasExited) break;
|
w.WriteLine(line);
|
}
|
|
break;
|
case WriteMode.WriteChars:
|
foreach (char ch in StdIn)
|
{
|
if (WriteSpeed > 0)
|
TapThread.Sleep(WriteSpeed);
|
if (process.HasExited) break;
|
w.Write(ch);
|
}
|
|
break;
|
}
|
}
|
// Writing to the input pipe will fail if the process has already exited
|
catch (Exception) when (process.HasExited)
|
{
|
// suppress
|
}
|
if (!process.HasExited)
|
process.StandardInput.Close();
|
|
if (!process.WaitForExit((int)TimeSpan.FromSeconds(10).TotalMilliseconds))
|
{
|
Log.Error("Process did not exit in a timely fashion.");
|
UpgradeVerdict(Verdict.Error);
|
return;
|
}
|
|
if (process.ExitCode == ExpectedExitCode)
|
UpgradeVerdict(Verdict.Pass);
|
else
|
{
|
Log.Error($"Expected exit code {ExpectedExitCode}, was {process.ExitCode}.");
|
UpgradeVerdict(Verdict.Fail);
|
}
|
}
|
}
|
}
|
