public string CodeToString(ChessExitCode c)
{
switch (c)
{
case ChessExitCode.Success: return("Success");
case ChessExitCode.TestFailure: return("TestFailure");
case ChessExitCode.ChessFailure: return("ChessFailure");
case ChessExitCode.ChessDeadlock: return("Deadlock");
case ChessExitCode.ChessLivelock: return("Livelock");
case ChessExitCode.ChessTimeout: return("Timeout");
case ChessExitCode.ChessNonDet: return("NonDeterminism");
case ChessExitCode.ChessInvalidTest: return("InvalidTest");
case ChessExitCode.ChessRace: return("Race");
case ChessExitCode.ChessInvalidObservation: return("InvalidObservation");
case ChessExitCode.ChessIncompleteInterleavingCoverage: return("IncompleteInterleavingCoverage");
default: throw new ArgumentException();
}
}
private void ReportErrorAndExitRaw(string message, ChessExitCode code, bool genRepro, bool fromExitCallback, Exception ex)
{
DiagnoseInstrumentedUninstrumented();
MErrorInfo errorInfo = ex == null ? null : new MErrorInfo(ex);
// It's only safe to write to the results printer if we aren't in the exit callback
if (!fromExitCallback)
{
// TODO: action? This var will always have the value of String.Empty.
var action = "";
if (message != "")
{
MChessChess.ReportError(message, action, errorInfo);
}
else if (code != 0)
{
// we have an error code but no message.
var newMessage = new ChessResult(code).ToString();
MChessChess.ReportError(newMessage, action, errorInfo);
}
MChessChess.ReportFinalStatistics((int)code);
}
if (genRepro)
{
// must call after all ReportWarning/ReportError calls
MChessChess.Done(!fromExitCallback);
}
else
{
// Note: The MChessChess.Done already implicitly calls CloseResults, so
// we only need to explicitly call it otherwise.
MChessChess.CloseResults();
}
// Invariant: this should be the only exit in the engine!!!
Environment.Exit((int)code);
}
/// <summary>
/// Converts a chess results.xml file into the xml element representing a MCUT test result.
/// </summary>
/// <param name="run"></param>
/// <param name="xtaskResults"></param>
/// <returns></returns>
public static XElement ChessXResultsToXTestResult(XElement xtaskResults, int?processExitCode, int?taskID)
{
// default to processing the chess results
if (xtaskResults == null || xtaskResults.Name != XChessNames.Results)
{
return(null);
}
// Rename the chess results element
xtaskResults.Name = XChessNames.ChessResults;
// For Chess results, we really only care about the results and actions available for each result
var results = (from xr in xtaskResults.Elements(XChessNames.Result)
let rType = EntityUtil.ParseMChessResultType((string)xr.Element(XChessNames.Label))
let acts = from xa in xr.Elements(XChessNames.Action)
select new {
Type = EntityUtil.ParseMChessResultActionType((string)xa.Attribute(XNames.AName)),
Race = (int?)xa.Attribute(XChessNames.ARace)
}
select new {
Type = rType,
Description = (string)xr.Element(XChessNames.Description),
XError = xr.Element(XConcurrencyNames.Error),
Actions = acts,
XSchedule = xr.Element(XChessNames.Schedule),
})
.ToList();
//var resultsActions = (from xa in xtaskResults.Elements(XChessNames.Action)
// select new {
// Type = EntityUtil.ParseMChessResultActionType((string)xa.Attribute(XNames.AName)),
// Race = (int?)xa.Attribute(XChessNames.ARace)
// });
var errorResults = results.Where(r => r.Type == MChessResultType.Error).ToList();
// Lets just assert that we only have one error, or else the 2nd error is the "Abnormal termination" error
Debug.Assert(errorResults.Count <= 1 || (errorResults.Count == 2 && errorResults[1].Description.StartsWith("Abnormal termination"))
, "According to the ResultsPrinter.cpp, there should only ever be one Error returned from Chess."
);
ChessExitCode?chessExitCode = null;
if (processExitCode.HasValue)
{
chessExitCode = (ChessExitCode)processExitCode.Value;
}
// First try to read from the results xml file
XElement xchessFinalStats = xtaskResults.Element(XChessNames.FinalStats);
ChessExitCode?resultExitCode = null;
if (xchessFinalStats != null)
{
resultExitCode = xchessFinalStats.Attribute(XChessNames.AExitCode).ParseXmlEnum <ChessExitCode>();
}
ChessExitCode exitCode = resultExitCode ?? chessExitCode ?? ChessExitCode.Unknown;
Debug.WriteLineIf(chessExitCode.HasValue && resultExitCode.HasValue && resultExitCode.Value != chessExitCode.Value
, String.Format("Task ({0}): The exit code from the process doesn't match the exit code reported in the results.xml file. process: {1}; result file: {2}."
, taskID ?? -1
, chessExitCode
, resultExitCode
));
TestResultType resultType;
string msg;
// Detect unit test errors first
if (exitCode == ChessExitCode.UnitTestAssertFailure)
{
resultType = TestResultType.AssertFailure;
Debug.Assert(errorResults.Count != 0);
msg = errorResults[0].Description;
}
else if (exitCode == ChessExitCode.UnitTestAssertInconclusive)
{
resultType = TestResultType.Inconclusive;
Debug.Assert(errorResults.Count != 0);
msg = errorResults[0].Description;
}
else if (exitCode == ChessExitCode.UnitTestException)
{
resultType = TestResultType.Exception;
Debug.Assert(errorResults.Count != 0);
msg = errorResults[0].Description;
}
else if (errorResults.Count != 0)
{
msg = errorResults[0].Description;
if (exitCode == ChessExitCode.ChessRace)
{
resultType = TestResultType.DataRace;
}
else if (exitCode == ChessExitCode.ChessLivelock)
{
resultType = TestResultType.Livelock;
}
else if (exitCode == ChessExitCode.ChessDeadlock)
{
resultType = TestResultType.Deadlock;
}
else
{
resultType = TestResultType.Error;
}
}
else if (results.Any(r => r.Type == MChessResultType.Race))
{
resultType = TestResultType.DataRace;
msg = results.Where(r => r.Type == MChessResultType.Race).First().Description;
}
else if (exitCode != ChessExitCode.Success)
{
resultType = TestResultType.Error;
msg = String.Format("Chess returned a non-zero exit code: {0}({1})", (int)exitCode, exitCode);
}
else
{
resultType = TestResultType.Passed;
msg = "Passed"; // Just let the UI use it's own msg for a passing test.
}
Debug.Assert(msg != null);
// If there's a single xerror, then propagate it to the root
var xerrors = (from r in results
where r.XError != null
select r.XError)
;
var singleXError = xerrors.Count() == 1 ? xerrors.Single() : null;
// Compose the final test result element
return(TestResultUtil.CreateXTestResult(resultType, msg, null
, new XAttribute(XTestResultNames.AChessExitCode, exitCode)
, singleXError
, xtaskResults
));
}
public ChessResult(ChessExitCode code)
{
this.Code = code;
this.Exception = null;
}
public ChessResult(ChessExitCode code, Exception exception)
{
this.Code = code;
this.Exception = exception;
}
private void ReportErrorAndExit(string message, ChessExitCode code, bool genRepro, Exception ex)
{
ReportErrorAndExitRaw(message, code, genRepro, false, ex);
}
public ExpectedChessResultAttribute(ChessExitCode exitCode)
{
ExitCode = exitCode;
}
public ExpectedChessResultAttribute(string key, ChessExitCode exitCode)
{
Key = key;
ExitCode = exitCode;
}
