public TrxResultsParser(string filename)
{
// Deserialize
_testRunType = DeserializeFile <TestRunType>(filename);
// Parse Results collection and Times element from the report
var resultsType = new ResultsType();
var testDefinitions = new TestRunTypeTestDefinitions();
foreach (var item in _testRunType.Items)
{
TypeSwitch.Switch(item,
TypeSwitch.Case <ResultsType>((results) => resultsType = results),
TypeSwitch.Case <TestRunTypeTimes>((results) => _testRunTimes = results),
TypeSwitch.Case <TestRunTypeTestDefinitions>((results) => testDefinitions = results)
);
}
_resultsFromReport = resultsType.Items.Select(item => (UnitTestResultType)item);
// Extract the codebase (name of DLL from the first record)
FileName =
Path.GetFileNameWithoutExtension(
testDefinitions.Items[0] == null
? string.Empty
: ((UnitTestType)testDefinitions.Items[0]).TestMethod.codeBase);
}
public void AddResults(ref List <System.Drawing.Bitmap> imgs, ResultsType resType)
{
if (resType == ResultsType.WHITE_LIGHT)
{
imgs_White_Light = imgs;
}
else if (resType == ResultsType.N3_FL)
{
imgs_N3_FL = imgs;
}
else if (resType == ResultsType.PHOS)
{
imgs_PHOS = imgs;
}
else if (resType == ResultsType.DP_FL)
{
imgs_DP_FL = imgs;
}
else if (resType == ResultsType.DP_FL2)
{
imgs_DP_FL2 = imgs;
}
else if (resType == ResultsType.DARK_BG)
{
imgs_DARK_BG = imgs;
}
}
/// <summary>
/// Processes the StatLight result.
/// </summary>
/// <param name="testRun">The test run.</param>
/// <returns>The test results.</returns>
internal IEnumerable <TrxResult> ProcessStatLightResult(TestRunType testRun)
{
IEnumerable <TrxResult> trxResults = new List <TrxResult>();
TestDefinitionType definition = GetDefinitions(testRun);
ResultsType results = GetResults(testRun);
if (definition == null || results == null)
{
return(trxResults);
}
if (definition.Items == null || results.Items == null)
{
return(trxResults);
}
IEnumerable <UnitTestType> unitTestDefinitions = definition.Items.OfType <UnitTestType>();
IEnumerable <UnitTestResultType> items = results.Items.OfType <UnitTestResultType>();
trxResults =
from e in unitTestDefinitions
from f in items
from g in this.TestCases
where e.id == f.testId && g.FullyQualifiedName == string.Concat(e.TestMethod.className, ".", e.TestMethod.name)
select new TrxResult
{
UnitTest = e,
UnitTestResult = f,
TestCase = g
};
return(trxResults);
}
public async Task <Result <LiveResultsResponse> > GetResults(ResultsType type, string location = null)
{
try
{
var liveResultsResponse = new LiveResultsResponse();
var result = await GetResultsByType(type, location);
if (result.IsFailure)
{
return(Result.Failure <LiveResultsResponse>("Could not load results"));
}
var selectedResults = result.Value;
var candidates = ConvertCandidates(selectedResults);
var counties =
selectedResults.Candidates.FirstOrDefault()?.Counties.Select(c => new County
{
Label = c.Key,
Id = c.Key
}).ToList();
liveResultsResponse.Candidates = candidates;
liveResultsResponse.Counties = counties ?? new List <County>();
return(Result.Ok(liveResultsResponse));
}
catch (Exception e)
{
_logger.LogError(e, "Encountered exception while retrieving results");
throw;
}
}
private TestDefinitionType CreateTestDefinitions(ResultsType results)
{
var unitTestDefinitions = new List <UnitTestType>();
foreach (var result in results.Items)
{
var r = result as UnitTestResultType;
unitTestDefinitions.Add(new UnitTestType
{
id = r.testId,
name = r.testName,
Items = new object[]
{
new BaseTestTypeExecution
{
id = r.executionId
},
},
TestMethod = new UnitTestTypeTestMethod
{
codeBase = "...",
adapterTypeName = "Microsoft.VisualStudio.TestTools.TestTypes.Unit.UnitTestAdapter",
className = r.testName
}
});
}
return(new TestDefinitionType
{
Items = unitTestDefinitions.ToArray(),
ItemsElementName = unitTestDefinitions.Select(u => ItemsChoiceType4.UnitTest).ToArray()
});
}
private async Task <Result <ElectionResultsData> > GetResultsByType(ResultsType type, string location)
{
try
{
string resultsType = type.ConvertEnumToString();
var localResultsResponse = await _resultsRepository.GetLatestResults(Consts.LOCAL, resultsType);
var diasporaResultsResponse = await _resultsRepository.GetLatestResults(Consts.DIASPORA, resultsType);
if (localResultsResponse.IsFailure || diasporaResultsResponse.IsFailure)
{
return(Result.Failure <ElectionResultsData>("Failed to retrieve data"));
}
var localResultsData = JsonConvert.DeserializeObject <ElectionResultsData>(localResultsResponse.Value.StatisticsJson);
var diasporaResultsData = JsonConvert.DeserializeObject <ElectionResultsData>(diasporaResultsResponse.Value.StatisticsJson);
var electionResultsData = StatisticsAggregator.CombineResults(localResultsData, diasporaResultsData);
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g1").Votes = 3485292;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g2").Votes = 527098;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g3").Votes = 1384450;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g4").Votes = 357014;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g5").Votes = 2051725;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g6").Votes = 32787;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g7").Votes = 30884;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g8").Votes = 30850;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g9").Votes = 27769;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g10").Votes = 815201;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g11").Votes = 39192;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g12").Votes = 244275;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g13").Votes = 48662;
electionResultsData.Candidates.FirstOrDefault(c => c.Id == "g14").Votes = 141316;
_totalCounted = electionResultsData.Candidates.Sum(c => c.Votes);
if (string.IsNullOrWhiteSpace(location) == false)
{
if (location == "TOTAL")
{
return(Result.Ok(electionResultsData));
}
if (location == "DSPR")
{
return(Result.Ok(diasporaResultsData));
}
if (location == "RO")
{
return(Result.Ok(localResultsData));
}
foreach (var candidate in electionResultsData.Candidates)
{
candidate.Votes = candidate.Counties[location];
}
}
return(Result.Ok(electionResultsData));
}
catch (Exception e)
{
_logger.LogError(e, $"Failed to retrieve results for type {type} and location {location}");
return(Result.Failure <ElectionResultsData>(e.Message));
}
}
static TestReportBase ReadInputInternal(string path, ref ExitCode.ExitCodeData errorCode)
{
string xmlReportFile = path;
if (!File.Exists(xmlReportFile))
{
// the input path could be a folder, try to detect it
string dir = xmlReportFile;
xmlReportFile = Path.Combine(dir, XMLReport_File);
if (!File.Exists(xmlReportFile))
{
// still not find, may be under "Report" sub folder? try it
xmlReportFile = Path.Combine(dir, XMLReport_SubDir_Report, XMLReport_File);
if (!File.Exists(xmlReportFile))
{
OutputWriter.WriteLine(Properties.Resources.ErrMsg_CannotFindXmlReportFile + " " + path);
errorCode = ExitCode.FileNotFound;
return(null);
}
}
}
// load XML from file with the specified XML schema
ResultsType root = XmlReportUtilities.LoadXmlFileBySchemaType <ResultsType>(xmlReportFile);
if (root == null)
{
errorCode = ExitCode.CannotReadFile;
return(null);
}
// try to load the XML data as a GUI test report
GUITestReport guiReport = new GUITestReport(root, xmlReportFile);
if (guiReport.TryParse())
{
return(guiReport);
}
// try to load as API test report
APITestReport apiReport = new APITestReport(root, xmlReportFile);
if (apiReport.TryParse())
{
return(apiReport);
}
// try to load as BP test report
BPTReport bptReport = new BPTReport(root, xmlReportFile);
if (bptReport.TryParse())
{
return(bptReport);
}
OutputWriter.WriteLine(Properties.Resources.ErrMsg_Input_InvalidFirstReportNode + " " + path);
errorCode = ExitCode.InvalidInput;
return(null);
}
private static string ConvertEnumToString(ResultsType type)
{
return(type
.GetType()
.GetMember(type.ToString())
.FirstOrDefault()
?.GetCustomAttribute <DescriptionAttribute>()
?.Description ?? type.ToString());
}
/// <summary>
/// Excute tests.
/// </summary>
/// <param name="test">
/// A <see cref="TestInfo"/>.
/// </param>
/// <param name="variables">
/// A <see cref="IDictionary{TKey,TValue}"/> variables.
/// </param>
/// <param name="previousTestResults">
/// A <see cref="IDictionary{TKey,TValue}"/> of previous results.
/// </param>
/// <param name="resultsType">
/// Results type.
/// </param>
/// <returns>
/// Results dictionary.
/// </returns>
private IDictionary <string, object> ExecuteTest(
TestInfo test,
IDictionary <string, object> variables,
IDictionary <string, object> previousTestResults,
out ResultsType resultsType)
{
var allParameters = new Dictionary <string, object>();
test.Parameters?.ToList().ForEach(kv => allParameters[kv.Key] = kv.Value);
previousTestResults.ToList().ForEach(kv => allParameters[kv.Key] = kv.Value);
var newParameters = this.EvaluateParameters(allParameters, variables);
var output = this._methodProxy.Execute(test.Api, newParameters);
var results = new Dictionary <string, object>()
{
{ "resultType", this._methodProxy.ReturnType },
};
if (output == null)
{
if (this._methodProxy.ReturnType == null)
{
resultsType = ResultsType.Void;
return(results);
}
resultsType = ResultsType.Object;
results["result"] = null;
return(results);
}
if (output.GetType().IsPrimitive)
{
resultsType = ResultsType.Primitive;
results["result"] = output;
return(results);
}
if (output is string)
{
resultsType = ResultsType.String;
results["result"] = output;
return(results);
}
if (output is IDictionary <string, object> )
{
resultsType = ResultsType.Dictionary;
return(output as IDictionary <string, object>);
}
resultsType = ResultsType.Object;
results["result"] = output;
return(results);
}
public TestReport(ResultsType root, string reportFile) : base(root, reportFile)
{
Iterations = new ReportNodeCollection <IterationReport>(this, ReportNodeFactory.Instance);
Groups = new ReportNodeCollection <GroupReport>(this, ReportNodeFactory.Instance);
Flows = new ReportNodeCollection <FlowReport>(this, ReportNodeFactory.Instance);
Branches = new ReportNodeCollection <BranchReport>(this, ReportNodeFactory.Instance);
BusinessComponents = new ReportNodeCollection <BusinessComponentReport>(this, ReportNodeFactory.Instance);
RecoverySteps = new ReportNodeCollection <RecoveryStepReport>(this, ReportNodeFactory.Instance);
GeneralSteps = new ReportNodeCollection <GeneralStepReport>(this, ReportNodeFactory.Instance);
AllBCsEnumerator = new ReportNodeEnumerator <BusinessComponentReport>();
}
public async Task <ElectionResultsData> GetResults(ResultsType type)
{
string resultsType = ConvertEnumToString(type);
var localResults = await _resultsRepository.GetLatestResults(Consts.LOCAL, resultsType);
var diasporaResults = await _resultsRepository.GetLatestResults(Consts.DIASPORA, resultsType);
var localResultsData = JsonConvert.DeserializeObject <ElectionResultsData>(localResults.StatisticsJson);
var diasporaResultsData = JsonConvert.DeserializeObject <ElectionResultsData>(diasporaResults.StatisticsJson);
return(StatisticsAggregator.CombineResults(localResultsData, diasporaResultsData));
}
public DataTable GetTestResultData()
{
string fileName;
DataTable testResultTable = null;
try
{
// Construct DirectoryInfo for the folder path passed in as an argument
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
//baseDirectory = baseDirectory.Substring(0, baseDirectory.IndexOf("bin"));
DirectoryInfo di = new DirectoryInfo(baseDirectory);
ResultTable resultTable = new ResultTable();
testResultTable = resultTable.CreateTestResultTable();
// For each .trx file in the given folder process it
foreach (FileInfo file in di.GetFiles("*.trx"))
{
fileName = file.Name;
// Deserialize TestRunType object from the trx file
StreamReader fileStreamReader = new StreamReader(file.FullName);
XmlSerializer xmlSer = new XmlSerializer(typeof(TestRunType));
TestRunType testRunType = (TestRunType)xmlSer.Deserialize(fileStreamReader);
// Navigate to UnitTestResultType object and update the sheet with test result information
foreach (object itob1 in testRunType.Items)
{
ResultsType resultsType = itob1 as ResultsType;
if (resultsType != null)
{
foreach (object itob2 in resultsType.Items)
{
UnitTestResultType unitTestResultType = itob2 as UnitTestResultType;
if (unitTestResultType != null)
{
DataRow row = testResultTable.NewRow();
row[Constant.PROCESSEDFILENAME] = fileName;
row[Constant.TESTID] = unitTestResultType.testId;
row[Constant.TESTNAME] = unitTestResultType.testName;
row[Constant.TESTOUTCOME] = unitTestResultType.outcome;
row[Constant.ERRORMESSAGE] = ((System.Xml.XmlNode[])(((OutputType)(((TestResultType)(unitTestResultType)).Items[0])).ErrorInfo.Message))[0].Value;
testResultTable.Rows.Add(row);
}
}
}
}
}
}
catch (Exception)
{
}
return(testResultTable);
}
private byte[] GetIndexLengthTypeAndId(int index, int totalLength, ResultsType resultsType, int id)
{
int length = totalLength - index;
tmpBuffer[0] = (byte)resultsType;
tmpBuffer[1] = (byte)id;
tmpBuffer[2] = (byte)(index >> 24);
tmpBuffer[3] = (byte)(index >> 16);
tmpBuffer[4] = (byte)(index >> 8);
tmpBuffer[5] = (byte)(index);
tmpBuffer[6] = (byte)(length >> 24);
tmpBuffer[7] = (byte)(length >> 16);
tmpBuffer[8] = (byte)(length >> 8);
tmpBuffer[9] = (byte)(length);
return(tmpBuffer);
}
private void Testresult()
{
var testRun = new TestRunType();
var resultContainer = new ResultsType();
var definitionContainer = new TestDefinitionType();
resultContainer.Items = results.ToArray();
definitionContainer.Items = definitions.ToArray();
resultContainer.ItemsElementName = new ItemsChoiceType3[results.Count];
definitionContainer.ItemsElementName = new ItemsChoiceType4[results.Count];
for (int i = 0; i < results.Count; i++)
{
resultContainer.ItemsElementName[i] = ItemsChoiceType3.UnitTestResult;
definitionContainer.ItemsElementName[i] = ItemsChoiceType4.UnitTest;
}
testRun.Items = new List <object> {
resultContainer, definitionContainer
}.ToArray();
string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "smoketestresult.trx");
var x = new XmlSerializer(testRun.GetType());
var xmlnsEmpty = new XmlSerializerNamespaces();
xmlnsEmpty.Add("x", "http://microsoft.com/schemas/VisualStudio/TeamTest/2010");
xmlnsEmpty.Add("x1", "http://www.w3.org/2001/XMLSchema-instance");
xmlnsEmpty.Add("x2", "http://www.w3.org/2001/XMLSchema");
using (var fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
x.Serialize(fs, testRun, xmlnsEmpty);
fs.Flush();
}
//Replace namespaces because on the publish test results to TFS, TFS doesnt accept the namespaces and we couldn't suppress them during serialization
string text = File.ReadAllText(filePath);
text = text.Replace("x:", "");
text = text.Replace("x1:", "");
text = text.Replace("x2:", "");
text = text.Replace("xmlns:x=\"http://microsoft.com/schemas/VisualStudio/TeamTest/2010\"", "xmlns=\"http://microsoft.com/schemas/VisualStudio/TeamTest/2010\"");
text = text.Replace("xmlns:x1=\"http://www.w3.org/2001/XMLSchema-instance\"", "");
text = text.Replace("xmlns:x2=\"http://www.w3.org/2001/XMLSchema\"", "");
File.WriteAllText(filePath, text);
}
private async Task <Result <ElectionResultsData> > GetResultsByType(ResultsType type, string location)
{
try
{
string resultsType = type.ConvertEnumToString();
var localResultsResponse = await _resultsRepository.GetLatestResults(Consts.LOCAL, resultsType);
var diasporaResultsResponse = await _resultsRepository.GetLatestResults(Consts.DIASPORA, resultsType);
if (localResultsResponse.IsFailure || diasporaResultsResponse.IsFailure)
{
return(Result.Failure <ElectionResultsData>("Failed to retrieve data"));
}
var localResultsData = JsonConvert.DeserializeObject <ElectionResultsData>(localResultsResponse.Value.StatisticsJson);
var diasporaResultsData = JsonConvert.DeserializeObject <ElectionResultsData>(diasporaResultsResponse.Value.StatisticsJson);
var electionResultsData = StatisticsAggregator.CombineResults(localResultsData, diasporaResultsData);
if (string.IsNullOrWhiteSpace(location) == false)
{
if (location == "TOTAL")
{
return(Result.Ok(electionResultsData));
}
if (location == "DSPR")
{
return(Result.Ok(diasporaResultsData));
}
if (location == "RO")
{
return(Result.Ok(localResultsData));
}
foreach (var candidate in electionResultsData.Candidates)
{
candidate.Votes = candidate.Counties[location];
}
}
return(Result.Ok(electionResultsData));
}
catch (Exception e)
{
_logger.LogError(e, $"Failed to retrieve results for type {type} and location {location}");
return(Result.Failure <ElectionResultsData>(e.Message));
}
}
private TestEntriesType1 CreateTestEntries(ResultsType results)
{
var entries = new TestEntryType[results.Items.Length];
for (int n = 0; n < entries.Length; n++)
{
var r = results.Items[n] as UnitTestResultType;
entries[n] = new TestEntryType
{
executionId = r.executionId,
testId = r.testId,
testListId = r.testListId
};
}
return(new TestEntriesType1
{
TestEntry = entries
});
}
public async Task <Result <LiveResultsResponse> > GetResults(ResultsType type, string location = null)
{
try
{
var liveResultsResponse = new LiveResultsResponse();
var result = await GetResultsByType(type, location);
if (result.IsFailure)
{
return(Result.Failure <LiveResultsResponse>("Could not load results"));
}
var selectedResults = result.Value;
var candidates = ConvertCandidates(selectedResults);
var counties =
selectedResults?.Candidates?.FirstOrDefault()?.Counties.Select(c => new County
{
Label = c.Key,
Id = c.Key
}).ToList();
liveResultsResponse.Candidates = candidates;
liveResultsResponse.Counties = counties ?? new List <County>();
var voterTurnout = await GetVoterTurnout();
if (voterTurnout.IsSuccess)
{
decimal totalVotes = voterTurnout.Value.TotalNationalVotes;
var percentage = Math.Round(_totalCounted / totalVotes, 2) * 100;
liveResultsResponse.PercentageCounted = percentage;
liveResultsResponse.VoterTurnout = totalVotes;
}
return(Result.Ok(liveResultsResponse));
}
catch (Exception e)
{
_logger.LogError(e, "Encountered exception while retrieving results");
throw;
}
}
public async Task <ActionResult <LiveResultsResponse> > GetLatestResults([FromQuery] ResultsType type, string location)
{
try
{
var key = $"results-{type.ConvertEnumToString()}-{location}";
var result = await _appCache.GetOrAddAsync(
key, () => _resultsAggregator.GetResults(type, location), DateTimeOffset.Now.AddMinutes(5));
if (result.IsFailure)
{
_appCache.Remove(key);
_logger.LogError(result.Error);
return(BadRequest(result.Error));
}
return(result.Value);
}
catch (Exception e)
{
_logger.LogError(e, "Exception encountered while retrieving results");
throw;
}
}
private static TestRunType GetVSTestRun(TestRunInfo testRunInfo)
{
var results = new ResultsType()
{
Items = testRunInfo.Tests.Select(MapTestResult).ToArray(),
ItemsElementName = testRunInfo.Tests.Select(_ => ItemsChoiceType3.UnitTestResult).ToArray()
};
var testDefinitions = new TestDefinitionType()
{
Items = testRunInfo.Tests.Select(MapTestDefinition).ToArray(),
ItemsElementName = testRunInfo.Tests.Select(_ => ItemsChoiceType4.UnitTest).ToArray()
};
var testEntries = new TestEntriesType1()
{
TestEntry = testRunInfo.Tests.Select(MapTestEntry).ToArray(),
};
var testLists = new TestRunTypeTestLists()
{
TestList = new[]
{
new TestListType()
{
name = "Results Not in a List", id = TestListId
},
new TestListType()
{
name = "All Loaded Results", id = "19431567-8539-422a-85d7-44ee4e166bda"
}
}
};
var resultsSummary = MapSummary(testRunInfo);
return(new TestRunType()
{
id = Guid.NewGuid().ToString(),
Items = new object[] { results, testDefinitions, testEntries, testLists, resultsSummary }
});
}
public static Results Create(ResultsType type, string message)
{
return(new Results {
ResultType = type, Message = message
});
}
public async Task <ElectionResultsData> GetLatestResults([FromQuery] ResultsType type)
{
return(await _resultsAggregator.GetResults(type));
}
public TestReport(ResultsType root, string reportFile) : base(root, reportFile)
{
Iterations = new ReportNodeCollection <IterationReport>(this, ReportNodeFactory.Instance);
AllStepsEnumerator = new ReportNodeEnumerator <StepReport>();
}
/// <summary>
/// Verifies the results of a test.
/// </summary>
/// <param name="test">
/// A <see cref="TestInfo"/> of test.
/// </param>
/// <param name="resultsType">
/// A <see cref="ResultsType"/> of result type.
/// </param>
/// <param name="results">
/// A <see cref="IDictionary{TKey,TValue}"/> of results.
/// </param>
/// <param name="variables">
/// A <see cref="IDictionary{TKey,TValue}"/> of variables.
/// </param>
private void VerifyResults(TestInfo test, ResultsType resultsType, IDictionary <string, object> results, IDictionary <string, object> variables)
{
try
{
if (resultsType == ResultsType.Primitive)
{
var finalExpectedValue = this.EvaluateParameters(
new Dictionary <string, object>()
{
{ "result", test.ReturnValue },
}, variables).First();
var result = results["result"];
this.Verify(test, () => result, finalExpectedValue.Value);
}
else if (resultsType == ResultsType.Void)
{
// Nothing to verify.
}
else if (resultsType == ResultsType.Object)
{
var evaluatedExpectedValues = this.EvaluateParameters(test.GetExpectedResults(), variables);
if (evaluatedExpectedValues.Any())
{
var returnObject = results["result"];
var output = JsonConvert.SerializeObject(returnObject, Formatting.Indented);
File.WriteAllText(@"c:\temp\test.json", output);
var expectedObjectJson = JsonConvert.SerializeObject(evaluatedExpectedValues.First().Value);
var returnType = results["resultType"];
var expectedObject = JsonConvert.DeserializeObject(expectedObjectJson?.ToString(), returnType as Type);
// Verify dictionary.
this.SendVerificationTraceInfo(test, returnObject, expectedObject);
returnObject.Should().BeEquivalentTo(expectedObject, test.Name);
}
}
else
{
var evaluatedExpectedValues = this.EvaluateParameters(test.GetExpectedResults(true), variables);
if (evaluatedExpectedValues.Any())
{
// Verify dictionary.
results.Remove("resultType");
this.SendVerificationTraceInfo(test, results, evaluatedExpectedValues);
results.Should().BeEquivalentTo(evaluatedExpectedValues, test.Name);
}
}
}
catch (Exception e)
{
var expectedObjectJson = JsonConvert.DeserializeObject <ExpectedExceptionInfo>(
JsonConvert.SerializeObject(test.GetExpectedResults()));
if (expectedObjectJson.Exception)
{
this.VerifyException(test, expectedObjectJson, e);
}
else
{
throw;
}
}
}
public override void SaveReport(IList <MutationDocumentResult> mutations, TimeSpan exectutionTime)
{
Log.Info("Saving TRX report..");
if (!mutations.Any())
{
Log.Info("No mutations to report.");
return;
}
try
{
var unitTestResults = CreateUnitTestResults(mutations);
var results = new ResultsType
{
Items = new List <UnitTestResultType>(unitTestResults).ToArray(),
};
results.ItemsElementName = new ItemsChoiceType3[results.Items.Length];
for (int n = 0; n < results.Items.Length; n++)
{
results.ItemsElementName[n] = ItemsChoiceType3.UnitTestResult;
}
var testRunType = new TestRunType
{
id = Guid.NewGuid().ToString(),
name = "mutation",
Items = new object[]
{
new TestRunTypeTimes
{
creation = DateTime.Now.ToString(),
finish = DateTime.Now.ToString(),
start = DateTime.Now.ToString()
},
new TestRunTypeResultSummary
{
outcome = mutations.All(m => !m.Survived) ? "Passed" : "Failed",
Items = new object[]
{
new CountersType
{
passed = mutations.Count(s => !s.Survived && s.CompilationResult != null && s.CompilationResult.IsSuccess),
failed = mutations.Count(s => s.Survived && s.CompilationResult != null && s.CompilationResult.IsSuccess),
completed = mutations.Count(s => s.CompilationResult != null && s.CompilationResult.IsSuccess),
error = mutations.Count(s => s.CompilationResult == null || !s.CompilationResult.IsSuccess)
}
}
},
results,
CreateTestDefinitions(results),
CreateTestEntries(results),
new TestRunTypeTestLists()
{
TestList = new TestListType[]
{
new TestListType()
{
id = results.Items.Any() ? ((UnitTestResultType)results.Items[0]).testListId : "No result found",
name = "All Loaded Results"
}
}
}
}
};
var xmlSerializer = new XmlSerializer(typeof(TestRunType));
using (var textWriter = new StringWriter())
{
xmlSerializer.Serialize(textWriter, testRunType);
var xml = textWriter
.ToString()
.Replace(" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"", string.Empty)
.Replace(" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"", string.Empty)
.Replace(" xsi:type=\"xsd:string\"", string.Empty);
File.WriteAllText(SavePath, xml);
}
}
catch (Exception ex)
{
Log.Error("Failed to save TRX report", ex);
throw;
}
Log.Info("TRX report saved successfully.");
}
