private static TestState getStatus(AutoTest.Messages.TestRunStatus testRunStatus)
{
if (testRunStatus == AutoTest.Messages.TestRunStatus.Failed)
return TestState.Failed;
if (testRunStatus == AutoTest.Messages.TestRunStatus.Ignored)
return TestState.Ignored;
return TestState.Passed;
}
internal static TestsFinishedArgs FromInternal(AutoTest.Messages.TestRunMessage msg)
{
return new TestsFinishedArgs()
{
Assembly = msg.Results.Assembly,
All = msg.Results.All.Select(x => getResult(msg.Results.Assembly, x)).ToArray()
};
}
private static RunActionType convertType(AutoTest.Messages.InformationType informationType)
{
if (informationType == AutoTest.Messages.InformationType.Build)
return RunActionType.Build;
else if (informationType == AutoTest.Messages.InformationType.TestRun)
return RunActionType.TestRun;
return RunActionType.PreProcessing;
}
private static StackLine getStackTrace(AutoTest.Messages.IStackLine x)
{
return new StackLine()
{
File = x.File,
LineNumber = x.LineNumber,
Method = x.Method
};
}
// This test uses the same set of types as the type system unittests use, and attempts to validate that the R2R usage of said types works well.
// This is done by touching the various types, and then relying on the verification logic in R2R images to detect failures.
static int Main()
{
ContainsGCPointersFieldsTest.Test();
// ExplicitTest.Test(); // Explicit layout is known to not quite match the runtime, and if enabled this set of tests will fail.
SequentialTest.Test();
AutoTest.Test();
EnumAlignmentTest.Test();
AutoTestWithVector.Test();
return(100);
}
private static BuildResult getBuildResult(AutoTest.Messages.BuildMessage x)
{
return new BuildResult()
{
ErrorMessage = x.ErrorMessage,
File = x.File,
LineNumber = x.LineNumber,
LinePosition = x.LinePosition
};
}
internal static ImmediateTestFeedbackArgs FromInternal(AutoTest.Messages.LiveTestStatusMessage msg)
{
return new ImmediateTestFeedbackArgs()
{
CurrentAssembly = msg.CurrentAssembly,
TestsCompleted = msg.TestsCompleted,
TotalNumberOfTests = msg.TotalNumberOfTests,
FailedTests = msg.FailedTests.Select(x => getTest(x)).ToArray(),
FailedButNowPassingTests = msg.FailedButNowPassingTests.Select(x => getTest(x)).ToArray()
};
}
internal static BuildFinishedArgs FromInternal(AutoTest.Messages.BuildRunMessage msg)
{
return new BuildFinishedArgs()
{
Project = msg.Results.Project,
ErrorCount = msg.Results.ErrorCount,
WarningCount = msg.Results.WarningCount,
Errors = msg.Results.Errors.Select(x => getBuildResult(x)).ToArray(),
Warnings = msg.Results.Warnings.Select(x => getBuildResult(x)).ToArray(),
TimeSpent = msg.Results.TimeSpent
};
}
internal static TestResult GetResult(string assembly, string message, string name, AutoTest.Messages.TestRunner runner, AutoTest.Messages.TestRunStatus status, IEnumerable<AutoTest.Messages.IStackLine> stackLines)
{
return new TestResult()
{
Assembly = assembly,
Message = message,
Name = name,
Runner = getRunner(runner),
Status = getStatus(status),
StackTrace = stackLines.Select(y => getStackTrace(y)).ToArray()
};
}
private static TestRunner getRunner(AutoTest.Messages.TestRunner testRunner)
{
if (testRunner == AutoTest.Messages.TestRunner.Any)
return TestRunner.Any;
if (testRunner == AutoTest.Messages.TestRunner.MSpec)
return TestRunner.MSpec;
if (testRunner == AutoTest.Messages.TestRunner.MSTest)
return TestRunner.MSTest;
if (testRunner == AutoTest.Messages.TestRunner.NUnit)
return TestRunner.NUnit;
return TestRunner.XUnit;
}
private static Run getRun(AutoTest.Messages.RunReport runReport)
{
return new Run()
{
RunDuration = runReport.RealTimeSpent,
NumberOfBuildsSucceeded = runReport.NumberOfBuildsSucceeded,
NumberOfBuildsFailed = runReport.NumberOfBuildsFailed,
NumberOfProjectsBuilt = runReport.NumberOfProjectsBuilt,
NumberOfTestsPassed = runReport.NumberOfTestsPassed,
NumberOfTestsFailed = runReport.NumberOfTestsFailed,
NumberOfTestsIgnored = runReport.NumberOfTestsIgnored,
NumberOfTestsRan = runReport.NumberOfTestsRan,
RunActions = runReport.RunActions.Select(x => new RunAction()
{
Type = convertType(x.Type),
Project = x.Project,
Assembly = x.Assembly,
TimeSpent = x.TimeSpent,
Succeeded = x.Succeeded
}).ToArray()
};
}
public void TestFinished(AutoTest.TestRunners.Shared.Results.TestResult result)
{
}
private static TestResult getTest(AutoTest.Messages.LiveTestStatus x)
{
return TestsFinishedArgs.GetResult(x.Assembly, x.Test.Message, x.Test.Name, x.Test.Runner, x.Test.Status, x.Test.StackTrace);
}
public static Messages.TestResult ConvertResult(AutoTest.TestRunners.Shared.Results.TestResult x)
{
return new Messages.TestResult(TestRunnerConverter.FromString(x.Runner),
getTestState(x.State),
x.TestName,
x.Message,
x.StackLines.Select(y => (IStackLine)new StackLineMessage(y.Method, y.File, y.Line)).ToArray<IStackLine>(),
x.DurationInMilliseconds
).SetDisplayName(x.TestDisplayName);
}
private static TestResult getResult(string assembly, AutoTest.Messages.TestResult x)
{
return GetResult(assembly, x.Message, x.Name, x.Runner, x.Status, x.StackTrace);
}
public void TestFinished(AutoTest.TestRunners.Shared.Results.TestResult result)
{
lock (_padLock)
{
if (_lastSend == DateTime.MinValue)
_lastSend = DateTime.Now;
_currentAssembly = result.Assembly;
_testCount++;
if (result.State == TestState.Passed && _runCache.Failed.Count(x => x.Value.Name.Equals(result.TestName)) != 0)
{
_bus.Publish(
new LiveTestStatusMessage(
_currentAssembly,
_totalTestCount,
_testCount,
new LiveTestStatus[] { },
new LiveTestStatus[] { new LiveTestStatus(result.Assembly, AutoTestTestRunner.ConvertResult(result)) }));
_lastSend = DateTime.Now;
return;
}
else if (result.State == TestState.Failed)
{
_bus.Publish(
new LiveTestStatusMessage(
_currentAssembly,
_totalTestCount,
_testCount,
new LiveTestStatus[] { new LiveTestStatus(result.Assembly, AutoTestTestRunner.ConvertResult(result)) },
new LiveTestStatus[] { }));
_lastSend = DateTime.Now;
return;
}
else if (DateTime.Now > _lastSend.AddSeconds(1))
{
_bus.Publish(
new LiveTestStatusMessage(
_currentAssembly,
_totalTestCount,
_testCount,
new LiveTestStatus[] { },
new LiveTestStatus[] { }));
_lastSend = DateTime.Now;
return;
}
}
}
public void TestFinished(AutoTest.TestRunners.Shared.Results.TestResult result)
{
Console.WriteLine(result.State.ToString() + " " + result.TestName);
}
private TestToRun[] getTest(AutoTest.Messages.TestRunner runner, string test)
{
return new TestToRun[] { new TestToRun(runner, test) };
}
