protected override bool Visit(ITestOutput testOutput)
{
var task = context.GetRemoteTask(testOutput);
task.Output(testOutput.Output);
return(context.ShouldContinue);
}
public static ITestRunner RegisterAsServer(ITestOutput output, Options options)
{
var host = new ServiceHost(output);
int i;
for (i = 0; i < 50; i += 10) {
try {
host.AddServiceEndpoint(typeof(ITestOutput), BindingFactory(), "http://localhost:" + (StartPort + i) + "/");
break;
} catch (AddressAlreadyInUseException) {
}
}
host.Open();
var start = DateTime.Now;
Exception final = null;
var res = new ChannelFactory<ITestRunner>(BindingFactory(), "http://localhost:" + (StartPort + i + 1) + "/").CreateChannel();
while (DateTime.Now - start < TimeSpan.FromSeconds(5)) {
try {
res.Ping();
return res;
} catch (Exception e) {
final = e;
}
}
throw final;
}
public void Run(string testExecutable, string testName, ITestOutput output)
{
var commandLineGenerator = new CommandLineGenerator();
var options = TestRunnerOptions.FromDteProperties(_dte.Properties["BoostTest", "TestRunner"]);
var testRunnerProcess = new ChildProcess(commandLineGenerator.Generate(testExecutable, testName, options));
testRunnerProcess.StartSuspended();
var process =
_dte.Debugger.LocalProcesses.Cast<EnvDTE.Process>().SingleOrDefault(p => p.ProcessID == testRunnerProcess.Pid);
if (process == null)
{
throw new InvalidOperationException("Couldn't find the process : " + testExecutable);
}
process.Attach();
testRunnerProcess.Resume()
.ContinueWith(
x =>
{
if (x.IsCompleted)
{
output.Clear();
output.OutputString(DateTime.Now.ToLongTimeString() + " : Test (Debug) : " + testName + "\n");
output.OutputString(x.Result);
}
});
}
public TestAdaptedSteps()
{
WorkflowServices.StepFactory = new AdaptedStepsFactory();
_workflow = new TestWorkflow();
_context = Substitute.For <ITestContext>();
_out = Substitute.For <ITestOutput>();
_context.Out.Returns(_out);
}
protected WorkflowTestsBase()
{
Context = Substitute.For <ITestContext>();
Output = Substitute.For <ITestOutput>();
TestFlags = new Dictionary <string, bool>();
Context.TestFlags.Returns(TestFlags);
Context.Out.Returns(Output);
Workflow = new TestWorkflow();
}
public Options(IList<string> args)
{
PipeName = Guid.NewGuid().ToString();
Assemblies = new List<string>();
Filters = new List<IFilter>();
HasError = !args.Any();
Action<string> argHandler = null;
CrashedTest = string.Empty;
IsChild = false;
OutputKind output = OutputKind.Console;
foreach (var arg in args) {
switch (arg) {
case "--from":
argHandler = Assemblies.Add;
break;
case "--named":
argHandler = s => Filters.Add(new NameFilter(s));
break;
case "--tagged":
argHandler = s => Filters.Add(new CategoryFilter(s, true));
break;
case "--nottagged":
argHandler = s => Filters.Add(new CategoryFilter(s, false));
break;
case "--parent":
IsChild = true;
argHandler = s => Parent = s;
break;
case "--startfrom":
argHandler = s => {
Filters.Add(new SkipUntilFilter(s));
CrashedTest = s;
};
break;
case "--teamcity":
output = OutputKind.Teamcity;
argHandler = null;
break;
default:
if (argHandler == null) {
HasError = true;
return;
}
argHandler(arg);
break;
}
}
Output = output == OutputKind.Console ? (ITestOutput)new ConsoleWriter() : new TeamcityOutput();
}
_TestOutput AdaptTestOutput(ITestOutput message)
{
var testCollectionUniqueID = UniqueIDForTestCollection(assemblyUniqueID, message.TestCollection);
var testClassUniqueID = UniqueIDForTestClass(testCollectionUniqueID, message.TestClass);
var testMethodUniqueID = UniqueIDForTestMethod(testClassUniqueID, message.TestMethod);
var testCaseUniqueID = message.TestCase.UniqueID;
var testUniqueID = UniqueIDForTest(testCaseUniqueID, message.Test);
return(new _TestOutput
{
AssemblyUniqueID = assemblyUniqueID,
Output = message.Output,
TestCaseUniqueID = testCaseUniqueID,
TestCollectionUniqueID = testCollectionUniqueID,
TestClassUniqueID = testClassUniqueID,
TestMethodUniqueID = testMethodUniqueID,
TestUniqueID = testUniqueID
});
}
public void Run(string testExecutable, string testName, ITestOutput output)
{
var commandLineGenerator = new CommandLineGenerator();
var options = TestRunnerOptions.FromDteProperties(_dte.Properties["BoostTest", "TestRunner"]);
var commandLine = commandLineGenerator.Generate(testExecutable, testName, options);
var testRunnerProcess = new ChildProcess(commandLine);
testRunnerProcess.Start()
.ContinueWith(
result =>
{
if (result.IsCompleted)
{
output.Clear();
output.OutputString(DateTime.Now.ToLongTimeString() + " : Test : " + testName + "\n");
output.OutputString(result.Result);
}
});
}
public void OnAfterDeserialize()
{
gen = (Generator)Serializer.Deserialize(serializedGen);
inputs = (ITestInput[])Serializer.Deserialize(serializedInputs);
output = (ITestOutput)Serializer.Deserialize(serializedOutput);
}
/// <summary>
/// Called when an instance of <see cref="ITestOutput"/> is sent to the message sink.
/// </summary>
/// <param name="testCaseOutput">The message.</param>
/// <returns>Return <c>true</c> to continue executing tests; <c>false</c> otherwise.</returns>
protected virtual bool Visit(ITestOutput testCaseOutput)
{
return(true);
}
public TestRunner(Options options)
{
Complete = new ManualResetEvent(false);
_options = options;
_output = ConnectionFactory.RegisterAsClient(this, options);
}
