public void MultipleAssemblies()
{
var clockTime = TimeSpan.FromSeconds(12.3456);
var @short = new ExecutionSummary {
Total = 2112, Errors = 6, Failed = 42, Skipped = 8, Time = 1.2345M
};
var nothing = new ExecutionSummary {
Total = 0
};
var longerName = new ExecutionSummary {
Total = 10240, Errors = 7, Failed = 96, Skipped = 4, Time = 3.4567M
};
var assemblyShortStarting = TestData.TestAssemblyStarting(assemblyUniqueID: "asm-short", assemblyName: "short");
var assemblyNothingStarting = TestData.TestAssemblyStarting(assemblyUniqueID: "asm-nothing", assemblyName: "nothing");
var assemblyLongerStarting = TestData.TestAssemblyStarting(assemblyUniqueID: "asm-longer", assemblyName: "longerName");
var summaryMessage = TestData.TestExecutionSummaries(clockTime, ("asm-short", @short), ("asm-nothing", nothing), ("asm-longer", longerName));
var handler = TestableDefaultRunnerReporterMessageHandler.Create();
handler.OnMessage(assemblyShortStarting);
handler.OnMessage(assemblyNothingStarting);
handler.OnMessage(assemblyLongerStarting);
handler.OnMessage(summaryMessage);
Assert.Collection(handler.Messages,
msg => Assert.Equal("[Imp] => === TEST EXECUTION SUMMARY ===", msg),
msg => Assert.Equal("[Imp] => longerName Total: 10240, Errors: 7, Failed: 96, Skipped: 4, Time: 3.457s", msg),
msg => Assert.Equal("[Imp] => nothing Total: 0", msg),
msg => Assert.Equal("[Imp] => short Total: 2112, Errors: 6, Failed: 42, Skipped: 8, Time: 1.235s", msg),
msg => Assert.Equal("[Imp] => ----- -- --- -- ------", msg),
msg => Assert.Equal("[Imp] => GRAND TOTAL: 12352 13 138 12 4.691s (12.346s)", msg)
);
}
private async Task RunClient(IODataClient client, int productID, ExecutionSummary result)
{
try
{
var product = await client.FindEntryAsync($"Products({productID})");
if (productID != Convert.ToInt32(product["ID"]))
{
lock (result)
{
result.NonEqualCount++;
}
}
}
catch (Exception)
{
lock (result)
{
result.ExceptionCount++;
}
}
finally
{
lock (result)
{
result.ExecutionCount++;
}
}
}
/// <summary>
/// Create a summary json of the execution
/// Example:
/// {
/// "StartTime": "0001-01-01T00:00:00",
/// "EndTime": "0001-01-01T00:00:00",
/// "Elapsed": "00:00:00",
/// "Runners": {
/// "Total": 1,
///"Parallel": false
///},
///"BusinessFlowsSummary": {
///"Total": 1,
///"Pass": 1,
///"Fail": 0,
///"Blocked": 0
///},
///"ActivitiesSummary": {
///"Total": 1,
///"Pass": 1,
///"Fail": 0,
///"Blocked": 0
///},
///"ActionsSummary": {
///"Total": 1,
///"Pass": 1,
///"Fail": 0,
///"Blocked": 0
///}
///}
/// </summary>
/// <returns>json string</returns>
public string CreateSummary()
{
ExecutionSummary executionSummary = new ExecutionSummary();
string json = executionSummary.Create(this);
return(json);
}
public VsExecutionSink(IMessageSinkWithTypes innerSink,
ITestExecutionRecorder recorder,
LoggerHelper logger,
Dictionary <string, TestCase> testCasesMap,
ITestFrameworkExecutionOptions executionOptions,
Func <bool> cancelledThunk)
{
this.innerSink = innerSink;
this.recorder = recorder;
this.logger = logger;
this.testCasesMap = testCasesMap;
this.executionOptions = executionOptions;
this.cancelledThunk = cancelledThunk;
ExecutionSummary = new ExecutionSummary();
Diagnostics.ErrorMessageEvent += HandleErrorMessage;
Execution.TestAssemblyCleanupFailureEvent += HandleTestAssemblyCleanupFailure;
Execution.TestAssemblyFinishedEvent += HandleTestAssemblyFinished;
Execution.TestCaseCleanupFailureEvent += HandleTestCaseCleanupFailure;
Execution.TestCaseFinishedEvent += HandleTestCaseFinished;
Execution.TestCaseStartingEvent += HandleTestCaseStarting;
Execution.TestClassCleanupFailureEvent += HandleTestClassCleanupFailure;
Execution.TestCleanupFailureEvent += HandleTestCleanupFailure;
Execution.TestCollectionCleanupFailureEvent += HandleTestCollectionCleanupFailure;
Execution.TestFailedEvent += HandleTestFailed;
Execution.TestMethodCleanupFailureEvent += HandleTestMethodCleanupFailure;
Execution.TestPassedEvent += HandleTestPassed;
Execution.TestSkippedEvent += HandleTestSkipped;
}
public void MultipleAssemblies()
{
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
var clockTime = TimeSpan.FromSeconds(12.3456);
var @short = new ExecutionSummary {
Total = 2112, Errors = 6, Failed = 42, Skipped = 8, Time = 1.2345M
};
var nothing = new ExecutionSummary {
Total = 0
};
var longerName = new ExecutionSummary {
Total = 10240, Errors = 7, Failed = 96, Skipped = 4, Time = 3.4567M
};
var message = new TestExecutionSummary(clockTime, new List <KeyValuePair <string, ExecutionSummary> > {
new KeyValuePair <string, ExecutionSummary>("short", @short),
new KeyValuePair <string, ExecutionSummary>("nothing", nothing),
new KeyValuePair <string, ExecutionSummary>("longerName", longerName),
});
var handler = TestableDefaultRunnerReporterWithTypesMessageHandler.Create();
handler.OnMessageWithTypes(message, null);
Assert.Collection(handler.Messages,
msg => Assert.Equal("[Imp] => === TEST EXECUTION SUMMARY ===", msg),
msg => Assert.Equal("[Imp] => short Total: 2112, Errors: 6, Failed: 42, Skipped: 8, Time: 1.235s", msg),
msg => Assert.Equal("[Imp] => nothing Total: 0", msg),
msg => Assert.Equal("[Imp] => longerName Total: 10240, Errors: 7, Failed: 96, Skipped: 4, Time: 3.457s", msg),
msg => Assert.Equal("[Imp] => ----- -- --- -- ------", msg),
msg => Assert.Equal("[Imp] => GRAND TOTAL: 12352 13 138 12 4.691s (12.346s)", msg)
);
}
void LogSummary(ExecutionSummary summary, Action <string> log = null, StringBuilder sb = null)
{
do_log($" Time: {summary.Time}", log, sb);
do_log($" Total tests run: {summary.Total}", log, sb);
do_log($" Total errors: {summary.Errors}", log, sb);
do_log($" Skipped tests: {summary.Skipped}", log, sb);
do_log($" Failed tests: {summary.Failed}", log, sb);
}
public DesignTimeExecutionVisitor(ITestExecutionSink sink, IDictionary <ITestCase, VsTestCase> conversions, IMessageSink next)
{
_sink = sink;
_conversions = conversions;
_next = next;
ExecutionSummary = new ExecutionSummary();
}
public ExecutionSummary Execute()
{
var executionSummary = new ExecutionSummary();
if (Validators != null)
{
foreach (var validator in Validators)
{
executionSummary.ValidationMessages.AddRange(validator.Validate(WorkflowBatch));
}
}
foreach (var workflow in WorkflowBatch.Workflows)
{
if (StartProcessWorkflow != null)
{
StartProcessWorkflow(this, new ProcessWorkflowEventArgs(workflow));
}
var result = new ExecutionResult
{
WorkflowName = workflow.Name,
ExecutedTasks = new List<String>()
};
if (ProcessWorkflow != null)
{
ProcessWorkflow(this, new ProcessWorkflowEventArgs(workflow));
}
foreach (var workflowTask in workflow.Tasks)
{
result.ExecutedTasks.Add(workflowTask.Name);
foreach (var workflowParameter in workflowTask.Parameters)
{
}
System.Threading.Thread.Sleep(workflowTask.Delay);
}
if (EndProcessWorkflow != null)
{
EndProcessWorkflow(this, new ProcessWorkflowEventArgs(workflow));
}
result.Succeeded = true;
executionSummary.Results.Add(result);
}
return executionSummary;
}
protected void Map(ExecutionSummary summary, execution_summaries summaryDB)
{
summaryDB.date = summary.Date;
summaryDB.symbol = summary.Symbol;
summaryDB.avg_px = summary.AvgPx;
summaryDB.cum_qty = summary.CumQty;
summaryDB.leaves_qty = summary.LeavesQty;
summaryDB.commission = summary.Commission;
summaryDB.text = summary.Text;
summaryDB.console = summary.Console;
summaryDB.account_number = summary.AccountNumber;
}
public VsExecutionVisitor(ITestExecutionRecorder recorder,
LoggerHelper logger,
Dictionary <ITestCase, TestCase> testCases,
ITestFrameworkExecutionOptions executionOptions,
Func <bool> cancelledThunk)
{
this.recorder = recorder;
this.logger = logger;
this.testCases = testCases;
this.executionOptions = executionOptions;
this.cancelledThunk = cancelledThunk;
ExecutionSummary = new ExecutionSummary();
}
public BlameCrashExecutionSink(TextWriter blameWriter)
{
this.blameWriter = blameWriter ?? throw new ArgumentNullException(nameof(blameWriter));
ExecutionSummary = new ExecutionSummary();
Execution.TestAssemblyFinishedEvent += HandleTestAssemblyFinished;
Execution.TestCaseFinishedEvent += HandleTestCaseFinished;
Execution.TestCaseStartingEvent += HandleTestCaseStarting;
Execution.TestFailedEvent += HandleTestFailed;
Execution.TestPassedEvent += HandleTestPassed;
Execution.TestSkippedEvent += HandleTestSkipped;
}
public DesignTimeExecutionSink(ITestExecutionSink sink, IDictionary <ITestCase, VsTestCase> conversions, IMessageSinkWithTypes next)
{
this.sink = sink;
this.conversions = conversions;
this.next = next;
ExecutionSummary = new ExecutionSummary();
TestAssemblyFinishedEvent += HandleTestAssemblyFinished;
TestFailedEvent += HandleTestFailed;
TestPassedEvent += HandleTestPassed;
TestStartingEvent += HandleTestStarting;
TestSkippedEvent += HandleTestSkipped;
}
protected override bool Visit(ITestAssemblyFinished assemblyFinished)
{
var result = base.Visit(assemblyFinished);
ExecutionSummary = new ExecutionSummary
{
Failed = assemblyFinished.TestsFailed,
Skipped = assemblyFinished.TestsSkipped,
Time = assemblyFinished.ExecutionTime,
Total = assemblyFinished.TestsRun
};
return(result);
}
void HandleTestAssemblyFinished(MessageHandlerArgs <ITestAssemblyFinished> args)
{
var assemblyFinished = args.Message;
ExecutionSummary = new ExecutionSummary
{
Failed = assemblyFinished.TestsFailed,
Skipped = assemblyFinished.TestsSkipped,
Time = assemblyFinished.ExecutionTime,
Total = assemblyFinished.TestsRun
};
Finished.Set();
}
public static TestAssemblyExecutionFinished TestAssemblyExecutionFinished(
string assemblyPath = DefaultAssemblyPath,
string configFilePath = DefaultConfigFilePath,
string targetFramework = DefaultTargetFramework,
bool diagnosticMessages = false,
decimal executionTime = 123.4567m,
bool internalDiagnosticMessages = false,
int maxParallelThreads = 2600,
bool parallelizeTestCollections = false,
int testsErrored = 95,
int testsFailed = DefaultCountFailed,
int testsRun = DefaultCountRun,
int testsSkipped = DefaultCountSkipped)
{
var project = new XunitProject();
var assembly = new XunitProjectAssembly(project)
{
AssemblyFileName = assemblyPath,
ConfigFileName = configFilePath,
TargetFramework = targetFramework
};
// See the ForExecution method to see which TestAssemblyConfiguration options are used for discovery
var executionOptions = _TestFrameworkOptions.ForExecution(new TestAssemblyConfiguration
{
DiagnosticMessages = diagnosticMessages,
InternalDiagnosticMessages = internalDiagnosticMessages,
MaxParallelThreads = maxParallelThreads,
ParallelizeTestCollections = parallelizeTestCollections
});
var executionSummary = new ExecutionSummary
{
Errors = testsErrored,
Failed = testsFailed,
Skipped = testsSkipped,
Time = executionTime,
Total = testsRun
};
return(new TestAssemblyExecutionFinished
{
Assembly = assembly,
ExecutionOptions = executionOptions,
ExecutionSummary = executionSummary
});
}
public void SingleAssembly()
{
var clockTime = TimeSpan.FromSeconds(12.3456);
var assembly = new ExecutionSummary {
Total = 2112, Errors = 6, Failed = 42, Skipped = 8, Time = 1.2345M
};
var message = new TestExecutionSummary(clockTime, new List <KeyValuePair <string, ExecutionSummary> > {
new KeyValuePair <string, ExecutionSummary>("assembly", assembly)
});
var handler = TestableDefaultRunnerReporterWithTypesMessageHandler.Create();
handler.OnMessageWithTypes(message, null);
Assert.Collection(handler.Messages,
msg => Assert.Equal("[Imp] => === TEST EXECUTION SUMMARY ===", msg),
msg => Assert.Equal("[Imp] => assembly Total: 2112, Errors: 6, Failed: 42, Skipped: 8, Time: 1.235s", msg)
);
}
public static ITestAssemblyExecutionFinished TestAssemblyExecutionFinished(bool diagnosticMessages = false, int total = 2112, int failed = 42, int skipped = 8, int errors = 6, decimal time = 123.456M)
{
var assembly = new XunitProjectAssembly {
AssemblyFilename = "testAssembly.dll", ConfigFilename = "testAssembly.dll.config"
};
var config = new TestAssemblyConfiguration {
DiagnosticMessages = diagnosticMessages, ShadowCopy = true
};
var summary = new ExecutionSummary {
Total = total, Failed = failed, Skipped = skipped, Errors = errors, Time = time
};
var result = Substitute.For <ITestAssemblyExecutionFinished, InterfaceProxy <ITestAssemblyExecutionFinished> >();
result.Assembly.Returns(assembly);
result.ExecutionOptions.Returns(TestFrameworkOptions.ForExecution(config));
result.ExecutionSummary.Returns(summary);
return(result);
}
public void SingleAssembly()
{
var clockTime = TimeSpan.FromSeconds(12.3456);
var summary = new ExecutionSummary {
Total = 2112, Errors = 6, Failed = 42, Skipped = 8, Time = 1.2345M
};
var assemblyStartingMessage = TestData.TestAssemblyStarting(assemblyUniqueID: "asm-id", assemblyName: "assembly");
var summaryMessage = TestData.TestExecutionSummaries(clockTime, "asm-id", summary);
var handler = TestableDefaultRunnerReporterMessageHandler.Create();
handler.OnMessage(assemblyStartingMessage);
handler.OnMessage(summaryMessage);
Assert.Collection(handler.Messages,
msg => Assert.Equal("[Imp] => === TEST EXECUTION SUMMARY ===", msg),
msg => Assert.Equal("[Imp] => assembly Total: 2112, Errors: 6, Failed: 42, Skipped: 8, Time: 1.235s", msg)
);
}
public async Task FindEntryParallelThreads()
{
var products = (await _client.FindEntriesAsync("Products")).ToArray();
var summary = new ExecutionSummary();
var tasks = new List <Task>();
foreach (var product in products)
{
var task = RunClient(_client, Convert.ToInt32(product["ID"]), summary);
tasks.Add(task);
}
Task.WaitAll(tasks.ToArray());
Assert.Equal(products.Count(), summary.ExecutionCount);
Assert.Equal(0, summary.ExceptionCount);
Assert.Equal(0, summary.NonEqualCount);
}
public WorkersRunningStateMachine(ExecutionSummary summary, SummarizedExecutionResult[] sortedResultStore, ILoggerFactory loggerFactory)
{
this.executionSummary = summary;
this.runningConnections = sortedResultStore.Select(x => x.WorkerId).ToHashSet(); // create copy
this.createWorkloadAndSetupCompletes = new HashSet <WorkerId>();
this.logger = loggerFactory.CreateLogger <WorkersRunningStateMachine>();
// create result lookup
var dict = new Dictionary <WorkerId, int>(sortedResultStore.Length);
for (int i = 0; i < sortedResultStore.Length; i++)
{
var item = sortedResultStore[i];
dict.TryAdd(item.WorkerId, i);
}
this.resultsIndex = dict;
this.resultsSorted = sortedResultStore;
}
public RunnerExecutionSink(IDictionary <string, VsTestCase> testCasesMap, ITestResultRecorder recorder, TextWriter blameWriter, TextWriter resultWriter)
{
this.blameWriter = blameWriter ?? throw new ArgumentNullException(nameof(blameWriter));
this.resultWriter = resultWriter ?? throw new ArgumentNullException(nameof(resultWriter));
this.recorder = recorder ?? throw new ArgumentNullException(nameof(recorder));
//this.logger = logger;
this.testCasesMap = testCasesMap ?? throw new ArgumentNullException(nameof(testCasesMap));
ExecutionSummary = new ExecutionSummary();
Execution.TestAssemblyFinishedEvent += HandleTestAssemblyFinished;
Execution.TestCaseFinishedEvent += HandleTestCaseFinished;
Execution.TestCaseStartingEvent += HandleTestCaseStarting;
Execution.TestFailedEvent += HandleTestFailed;
Execution.TestPassedEvent += HandleTestPassed;
Execution.TestSkippedEvent += HandleTestSkipped;
}
public async Task FindEntryParallelThreadsRenewConnection()
{
var client = new ODataClient(new ODataClientSettings()
{
BaseUri = _serviceUri, RenewHttpConnection = true
});
var products = (await client.FindEntriesAsync("Products")).ToArray();
var summary = new ExecutionSummary();
var tasks = new List <Task>();
foreach (var product in products)
{
var task = RunClient(client, Convert.ToInt32(product["ID"]), summary);
tasks.Add(task);
}
Task.WaitAll(tasks.ToArray());
Assert.Equal(products.Count(), summary.ExecutionCount);
Assert.Equal(0, summary.ExceptionCount);
Assert.Equal(0, summary.NonEqualCount);
}
/// <summary>
/// <see cref="StarcounterXunitRunner.Start(string, string)"/> for description.
/// </summary>
/// <param name="typeName"></param>
/// <param name="testReportName"></param>
private void ExecuteTests(string typeName = null, string testReportName = null)
{
ExecutionSummary executionSummary = null;
XunitProjectAssembly assembly = new XunitProjectAssembly
{
AssemblyFilename = assemblyLocation,
ConfigFilename = null
};
XElement assembliesElement = new XElement("assemblies");
XElement assemblyElement = new XElement("assembly");
// Logger
var verboserReporter = new XunitReporters.VerboseReporter();
IRunnerLogger logger = new ConsoleRunnerLogger(useColors: true);
IMessageSinkWithTypes reporterMessageHandler = MessageSinkWithTypesAdapter.Wrap(verboserReporter.CreateMessageHandler(logger));
// Option setup
ITestFrameworkDiscoveryOptions discoveryOptions = TestFrameworkOptions.ForDiscovery(null);
ITestFrameworkExecutionOptions executionOptions = TestFrameworkOptions.ForExecution(null);
executionOptions.SetSynchronousMessageReporting(true);
executionOptions.SetDisableParallelization(DeveloperMode || !RunTestsInParallel);
executionOptions.SetDiagnosticMessages(true);
var assemblyDisplayName = Path.GetFileNameWithoutExtension(assembly.AssemblyFilename);
var appDomainSupport = assembly.Configuration.AppDomainOrDefault;
var shadowCopy = assembly.Configuration.ShadowCopyOrDefault;
var clockTime = Stopwatch.StartNew();
bool cancel = false;
using (var controller = new XunitFrontController(
appDomainSupport: AppDomainSupport.Denied,
assemblyFileName: assembly.AssemblyFilename,
configFileName: null,
shadowCopy: shadowCopy,
shadowCopyFolder: null,
sourceInformationProvider: null,
diagnosticMessageSink: null))
using (var discoverySink = new TestDiscoverySink(() => cancel))
{
// Discover & filter the tests
reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryStarting(
assembly: assembly,
appDomain: controller.CanUseAppDomains && appDomainSupport != AppDomainSupport.Denied,
shadowCopy: shadowCopy,
discoveryOptions: discoveryOptions));
if (typeName != null)
{
controller.Find(typeName, false, discoverySink, discoveryOptions);
}
else
{
controller.Find(false, discoverySink, discoveryOptions);
}
discoverySink.Finished.WaitOne();
var testCasesDiscovered = discoverySink.TestCases.Count;
var filteredTestCases = discoverySink.TestCases.Where(TestCaseFilter).ToList();
var testCasesToRun = filteredTestCases.Count;
reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryFinished(assembly, discoveryOptions, testCasesDiscovered, testCasesToRun));
// Run the filtered tests
if (testCasesToRun == 0)
{
executionSummary = new ExecutionSummary();
}
else
{
reporterMessageHandler.OnMessage(new TestAssemblyExecutionStarting(assembly, executionOptions));
IExecutionSink resultsSink = new DelegatingExecutionSummarySink(reporterMessageHandler, () => cancel, (path, summary) => { executionSummary = summary; });
if (assemblyElement != null)
{
resultsSink = new DelegatingXmlCreationSink(resultsSink, assemblyElement);
}
controller.RunTests(filteredTestCases, resultsSink, executionOptions);
resultsSink.Finished.WaitOne();
reporterMessageHandler.OnMessage(new TestAssemblyExecutionFinished(assembly, executionOptions, resultsSink.ExecutionSummary));
assembliesElement.Add(assemblyElement);
}
}
clockTime.Stop();
assembliesElement.Add(new XAttribute("timestamp", DateTime.Now.ToString(CultureInfo.InvariantCulture)));
if (executionSummary != null)
{
Console.WriteLine();
KeyValuePair <string, ExecutionSummary> kvpExecutionSummary = new KeyValuePair <string, ExecutionSummary>(this.assebmlyName, executionSummary);
reporterMessageHandler.OnMessage(new TestExecutionSummary(clockTime.Elapsed, new List <KeyValuePair <string, ExecutionSummary> > {
kvpExecutionSummary
}));
if (testReportName != null)
{
// Create folder if it does not exist
FileInfo fi = new FileInfo(testReportName);
DirectoryInfo directory = fi.Directory;
if (!directory.Exists)
{
Directory.CreateDirectory(directory.FullName);
}
CreateXmlTestReport(assembliesElement, fi);
CreateHtmlTestReport(assembliesElement, fi);
}
Console.WriteLine();
Console.WriteLine();
}
}
public void Add(ExecutionSummary partial)
{
Passed += partial.Passed;
Failed += partial.Failed;
Skipped += partial.Skipped;
}
public static execution_summaries Map(this ExecutionSummary source)
{
return(Mapper.Map <ExecutionSummary, execution_summaries>(source));
}
public void ExecuteAction()
{
if (String.IsNullOrEmpty(FileName))
{
return;
}
var batch = serializer.DeserializeFrom<WorkflowBatch>(FileName);
var runner = new WorkflowRunner(batch);
ExecutionSummary = new ExecutionSummary();
foreach (var item in runner.GetValidationMessages())
{
ExecutionSummary.ValidationMessages.Add(item);
}
ExecutionWorker = new BackgroundWorker();
ExecutionWorker.DoWork += (sender, eventArgs) =>
{
runner.StartProcessWorkflow += (source, args) =>
{
Status = String.Format("Starting workflow: '{0}'", args.Workflow.Name);
};
runner.ProcessWorkflow += (source, args) =>
{
Status = String.Format("Processing workflow: '{0}'", args.Workflow.Name);
};
runner.EndProcessWorkflow += (source, args) =>
{
Status = String.Format("Ending workflow: '{0}'", args.Workflow.Name);
};
foreach (var item in runner.ExecuteWorkflows())
{
App.Current.Dispatcher.Invoke(() =>
{
Results.Add(item);
});
}
};
ExecutionWorker.RunWorkerAsync();
}
public void Insert(ExecutionSummary summary)
{
execution_summaries execSummaryDB = GetById(summary.Id);
if (execSummaryDB == null)
{
execution_summaries summaries = new execution_summaries();
Map(summary, summaries);
summaries.positions = new positions();
Map(summary.Position, summaries.positions);
foreach (Order order in summary.Position.Orders)
{
orders orderBD = new orders();
Map(order, orderBD);
summaries.positions.orders.Add(orderBD);
}
foreach (ExecutionReport report in summary.Position.ExecutionReports)
{
execution_reports reportsDB = new execution_reports();
Map(report, reportsDB);
summaries.positions.execution_reports.Add(reportsDB);
}
ctx.execution_summaries.AddObject(summaries);
ctx.SaveChanges();
summary.Id = summaries.id;
int i = 0;
foreach (orders orderDB in summaries.positions.orders)
{
summary.Position.Orders[i].Id = orderDB.id;
i++;
}
}
else
{
Map(summary, execSummaryDB);
Map(summary.Position, execSummaryDB.positions);
foreach (Order order in summary.Position.Orders)
{
if (!execSummaryDB.positions.orders.Any(x => x.id == order.Id))
{
orders orderBD = new orders();
Map(order, orderBD);
execSummaryDB.positions.orders.Add(orderBD);
}
}
foreach (ExecutionReport report in summary.Position.ExecutionReports)
{
if (report.TransactTime.HasValue && !execSummaryDB.positions.execution_reports.Any(x => x.transact_time.HasValue && DateTime.Compare(x.transact_time.Value, report.TransactTime.Value) == 0))
{
execution_reports reportsDB = new execution_reports();
Map(report, reportsDB);
execSummaryDB.positions.execution_reports.Add(reportsDB);
}
}
ctx.SaveChanges();
}
}
XElement ExecuteAssembly(object consoleLock,
XunitProjectAssembly assembly,
bool needsXml,
bool?parallelizeTestCollections,
int?maxThreadCount,
bool diagnosticMessages,
bool noColor,
bool failSkips,
bool stopOnFail,
XunitFilters filters,
bool internalDiagnosticMessages)
{
if (cancel)
{
return(null);
}
var assemblyElement = needsXml ? new XElement("assembly") : null;
try
{
if (!ValidateFileExists(consoleLock, assembly.ConfigFilename))
{
return(null);
}
// Turn off pre-enumeration of theories, since there is no theory selection UI in this runner
assembly.Configuration.PreEnumerateTheories = false;
assembly.Configuration.DiagnosticMessages |= diagnosticMessages;
assembly.Configuration.InternalDiagnosticMessages |= internalDiagnosticMessages;
// Setup discovery and execution options with command-line overrides
var discoveryOptions = TestFrameworkOptions.ForDiscovery(assembly.Configuration);
var executionOptions = TestFrameworkOptions.ForExecution(assembly.Configuration);
executionOptions.SetStopOnTestFail(stopOnFail);
if (maxThreadCount.HasValue)
{
executionOptions.SetMaxParallelThreads(maxThreadCount);
}
if (parallelizeTestCollections.HasValue)
{
executionOptions.SetDisableParallelization(!parallelizeTestCollections.GetValueOrDefault());
}
var assemblyDisplayName = Path.GetFileNameWithoutExtension(assembly.AssemblyFilename);
var diagnosticMessageSink = DiagnosticMessageSink.ForDiagnostics(consoleLock, assemblyDisplayName, diagnosticMessages, noColor);
var internalDiagnosticsMessageSink = DiagnosticMessageSink.ForInternalDiagnostics(consoleLock, assemblyDisplayName, internalDiagnosticMessages, noColor);
var longRunningSeconds = assembly.Configuration.LongRunningTestSecondsOrDefault;
using var testFramework = new XunitTestFramework(diagnosticMessageSink, assembly.ConfigFilename);
var entryAssembly = Assembly.GetEntryAssembly();
var assemblyInfo = new ReflectionAssemblyInfo(entryAssembly);
var discoverySink = new TestDiscoverySink(() => cancel);
using (var testDiscoverer = testFramework.GetDiscoverer(assemblyInfo))
{
// Discover & filter the tests
reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryStarting(assembly, appDomain: false, shadowCopy: false, discoveryOptions));
testDiscoverer.Find(includeSourceInformation: false, discoverySink, discoveryOptions);
discoverySink.Finished.WaitOne();
}
var testCasesDiscovered = discoverySink.TestCases.Count;
var filteredTestCases = discoverySink.TestCases.Where(filters.Filter).ToList();
var testCasesToRun = filteredTestCases.Count;
reporterMessageHandler.OnMessage(new TestAssemblyDiscoveryFinished(assembly, discoveryOptions, testCasesDiscovered, testCasesToRun));
// Run the filtered tests
if (testCasesToRun == 0)
{
executionSummary = new ExecutionSummary();
}
else
{
reporterMessageHandler.OnMessage(new TestAssemblyExecutionStarting(assembly, executionOptions));
IExecutionSink resultsSink = new DelegatingExecutionSummarySink(reporterMessageHandler, () => cancel);
if (assemblyElement != null)
{
resultsSink = new DelegatingXmlCreationSink(resultsSink, assemblyElement);
}
if (longRunningSeconds > 0)
{
resultsSink = new DelegatingLongRunningTestDetectionSink(resultsSink, TimeSpan.FromSeconds(longRunningSeconds), MessageSinkWithTypesAdapter.Wrap(diagnosticMessageSink));
}
if (failSkips)
{
resultsSink = new DelegatingFailSkipSink(resultsSink);
}
using var executor = testFramework.GetExecutor(entryAssembly.GetName());
executor.RunTests(filteredTestCases, resultsSink, executionOptions);
resultsSink.Finished.WaitOne();
executionSummary = resultsSink.ExecutionSummary;
reporterMessageHandler.OnMessage(new TestAssemblyExecutionFinished(assembly, executionOptions, resultsSink.ExecutionSummary));
if (stopOnFail && resultsSink.ExecutionSummary.Failed != 0)
{
Console.WriteLine("Canceling due to test failure...");
cancel = true;
}
}
}
catch (Exception ex)
{
failed = true;
var e = ex;
while (e != null)
{
Console.WriteLine($"{e.GetType().FullName}: {e.Message}");
if (internalDiagnosticMessages)
{
Console.WriteLine(e.StackTrace);
}
e = e.InnerException;
}
}
return(assemblyElement);
}
public static TestExecutionSummaries TestExecutionSummaries(
TimeSpan clockTime,
string assemblyUniqueID,
ExecutionSummary summary) =>
TestExecutionSummaries(clockTime, (assemblyUniqueID, summary));
public static async Task <int> RunDataCollector(DataContainer data)
{
var updateSession = new UpdateSession();
var executionSummary = new ExecutionSummary();
var totalProjects = data.Projects.Count;
if (totalProjects == 0)
{
Log.GlobalLog.AddToLog(new LogMessage($"No projects found. Data collection aborted.", Log.PriorityLevels.UltraHigh));
return(-1);
}
Log.GlobalLog.AddToLog(new LogMessage($"{ totalProjects } projects loaded.", Log.PriorityLevels.Medium));
var totalUpdateTimes = data.UpdateTimes.Count;
// DONE: Check if there are no update times.
// TO DO [OPTIONAL]: Remove duplicate UpdateTimes (i.e., have the same HourRunTime) and order ascending (by HourRunTime). Decided not to as replicating UpdateTimes could be done on purpose to collect data faster for the replicated project(s).
if (totalUpdateTimes == 0)
{
Log.GlobalLog.AddToLog(new LogMessage($"No update times found. Data collection aborted.", Log.PriorityLevels.UltraHigh));
return(-1);
}
Log.GlobalLog.AddToLog(new LogMessage($"{ totalUpdateTimes } update times loaded.", Log.PriorityLevels.Medium));
// DONE: Filter out non drivable streets (requires 1. Changing 'HighwayType' to an enum; 2. Reparsing the data to reflect changes).
// DONE: [OPTIONAL]: Consider other filters based on data structure --> Could use waypoints for two way edge traversal, i.e., waypoint 1 = A-->B, waypoint 2 = B-->A. A far more complex example would be hardcore graphing to optimise a single Google request into max waypoints.
var prioritisedUpdates =
data.Edges.Where(e => AcceptableHighwayTypes.Contains((Edge.HighwayTypes)e.HighwayType)) // Filter out non accepted highway types.
.GroupBy(e => e.Updates.Count, e => e, // Group edges by update count.
(key, g) => new { UpdateCount = key, Edges = g.ToList()
.OrderBy(edge => edge.Fid).ToList() }) // Order individual groupings by FID.
.OrderBy(g => g.UpdateCount) // Order groups by update count.
.Select(x => new { x.UpdateCount, x.Edges }) // Transform anonymous type to new { int, List<Edge> }
.SelectMany(x => x.Edges.Select(y => new Tuple <int, Edge, UpdateTime>(x.UpdateCount, y, data.UpdateTimes[x.UpdateCount % data.UpdateTimes.Count]))) // Flatten groups into a list of Tuples<int, Edge, UpdateTime>.
.ToList();
var edgeQueue = new ConcurrentQueue <Tuple <int, Edge, UpdateTime> >(prioritisedUpdates);
Log.GlobalLog.AddToLog(new LogMessage($"{ edgeQueue.Count } edges loaded. { data.Edges.Count - edgeQueue.Count } filtered out (from an initial total of { data.Edges.Count }).", Log.PriorityLevels.Medium));
if (edgeQueue.Count == 0)
{
Log.GlobalLog.AddToLog(new LogMessage($"No edges found. Data collection aborted.", Log.PriorityLevels.UltraHigh));
return(-1);
}
Log.GlobalLog.AddToLog(new LogMessage($"Data collection started.", Log.PriorityLevels.Medium));
data.Projects.ForEach(p => p.LoadProject());
data.UpdateSessions.Add(updateSession);
updateSession.RunTimeStartedAt = DateTime.Now;
updateSession.ExecutionSummary = executionSummary;
var tasks = new List <Task>(data.Projects
.Select(p => Task.Run(() => p.GetUpdates(edgeQueue, new List <UpdateTime>(data.UpdateTimes))))
.ToList());
await Task.WhenAll(tasks);
Log.GlobalLog.AddToLog(new LogMessage($"Data collection completed successfully.", Log.PriorityLevels.Medium));
// DONE: Overall summary.
data.Projects.ForEach(p => executionSummary.Update(p.Summary));
Log.GlobalLog.AddToLog(new LogMessage($"{ executionSummary }", Log.PriorityLevels.High));
updateSession.ExecutionSummary = executionSummary;
updateSession.RunTimeCompletedAt = DateTime.Now;
return(0);
}
