/// <summary>
/// Dispatch a single work item for execution. The first
/// work item dispatched is saved as the top-level
/// work item and a thread is created on which to
/// run it. Subsequent calls come from the top level
/// item or its descendants on the proper thread.
/// </summary>
/// <param name="work">The item to dispatch</param>
public void Dispatch(WorkItem work)
{
#if PORTABLE
if (work != null)
{
work.Execute();
}
#else
if (_topLevelWorkItem != null)
{
work.Execute();
}
else
{
_topLevelWorkItem = work;
_runnerThread = new Thread(RunnerThreadProc);
#if !NETCF && !SILVERLIGHT
if (work.TargetApartment == ApartmentState.STA)
{
_runnerThread.SetApartmentState(ApartmentState.STA);
}
#endif
_runnerThread.Start();
}
#endif
}
/// <summary>
/// Dispatch a single work item for execution. The first
/// work item dispatched is saved as the top-level
/// work item and a thread is created on which to
/// run it. Subsequent calls come from the top level
/// item or its descendants on the proper thread.
/// </summary>
/// <param name="work">The item to dispatch</param>
public void Dispatch(WorkItem work)
{
#if PORTABLE || NETSTANDARD1_6
if (work != null)
{
work.Execute();
}
#else
if (_topLevelWorkItem != null)
{
work.Execute();
}
else
{
_topLevelWorkItem = work;
_runnerThread = new Thread(RunnerThreadProc);
if (work.TargetApartment == ApartmentState.STA)
{
_runnerThread.SetApartmentState(ApartmentState.STA);
}
_runnerThread.Start();
}
#endif
}
/// <summary>
/// Dispatch a single work item for execution by
/// executing it directly.
/// <param name="work">The item to dispatch</param>
/// </summary>
public void Dispatch(WorkItem work)
{
if (work != null)
{
work.Execute();
}
}
private void TestWorkerThreadProc()
{
_running = true;
try
{
while (_running)
{
_currentWorkItem = WorkQueue.Dequeue();
if (_currentWorkItem == null)
{
break;
}
log.Info("{0} executing {1}", _workerThread.Name, _currentWorkItem.Name);
Busy(this, EventArgs.Empty);
_currentWorkItem.TestWorker = this;
_currentWorkItem.Execute();
Idle(this, EventArgs.Empty);
++_workItemCount;
}
}
finally
{
log.Info("{0} stopping - {1} WorkItems processed.", Name, _workItemCount);
}
}
/// <summary>
/// Dispatch a single work item for execution. The first
/// work item dispatched is saved as the top-level
/// work item and a thread is created on which to
/// run it. Subsequent calls come from the top level
/// item or its descendants on the proper thread.
/// </summary>
/// <param name="work">The item to dispatch</param>
public void Dispatch(WorkItem work)
{
#if PORTABLE
if (work != null)
work.Execute();
#else
if (_topLevelWorkItem != null)
work.Execute();
else
{
_topLevelWorkItem = work;
_runnerThread = new Thread(RunnerThreadProc);
_runnerThread.Start();
}
#endif
}
private void Dispatch(WorkItem work, ExecutionStrategy strategy)
{
log.Debug("Using {0} strategy for {1}", strategy, work.Name);
switch (strategy)
{
default:
case ExecutionStrategy.Direct:
work.Execute();
break;
case ExecutionStrategy.Parallel:
if (work.TargetApartment == ApartmentState.STA)
{
ParallelSTAQueue.Enqueue(work);
}
else
{
ParallelQueue.Enqueue(work);
}
break;
case ExecutionStrategy.NonParallel:
if (work.TargetApartment == ApartmentState.STA)
{
NonParallelSTAQueue.Enqueue(work);
}
else
{
NonParallelQueue.Enqueue(work);
}
break;
}
}
/// <summary>
/// Dispatch a single work item for execution by
/// executing it directly.
/// </summary>
/// <param name="work">The item to dispatch</param>
public Task Dispatch(WorkItem work)
{
if (work != null)
{
return(work.Execute());
}
return(Task.Delay(0));
}
/// <summary>
/// Dispatch a single work item for execution. The first
/// work item dispatched is saved as the top-level
/// work item and a thread is created on which to
/// run it. Subsequent calls come from the top level
/// item or its descendants on the proper thread.
/// </summary>
/// <param name="work">The item to dispatch</param>
public void Dispatch(WorkItem work)
{
#if PORTABLE || NETSTANDARD1_6
if (work != null)
work.Execute();
#else
if (_topLevelWorkItem != null)
work.Execute();
else
{
_topLevelWorkItem = work;
_runnerThread = new Thread(RunnerThreadProc);
if (work.TargetApartment == ApartmentState.STA)
_runnerThread.SetApartmentState(ApartmentState.STA);
_runnerThread.Start();
}
#endif
}
/// <summary>
/// Dispatch a single work item for execution. The first
/// work item dispatched is saved as the top-level
/// work item and a thread is created on which to
/// run it. Subsequent calls come from the top level
/// item or its descendants on the proper thread.
/// </summary>
/// <param name="work">The item to dispatch</param>
public void Dispatch(WorkItem work)
{
#if PORTABLE
if (work != null)
{
work.Execute();
}
#else
if (_topLevelWorkItem != null)
{
work.Execute();
}
else
{
_topLevelWorkItem = work;
_runnerThread = new Thread(RunnerThreadProc);
_runnerThread.Start();
}
#endif
}
/// <summary>
/// Dispatch a single work item for execution. The first
/// work item dispatched is saved as the top-level
/// work item and a thread is created on which to
/// run it. Subsequent calls come from the top level
/// item or its descendants on the proper thread.
/// </summary>
/// <param name="work">The item to dispatch</param>
public void Dispatch(WorkItem work)
{
if (_topLevelWorkItem != null)
work.Execute();
else
{
_topLevelWorkItem = work;
_runnerThread = new Thread(RunnerThreadProc);
_runnerThread.Start();
}
}
/// <summary>
/// Dispatch a single work item for execution. The first
/// work item dispatched is saved as the top-level
/// work item and a thread is created on which to
/// run it. Subsequent calls come from the top level
/// item or its descendants on the proper thread.
/// </summary>
/// <param name="work">The item to dispatch</param>
public void Dispatch(WorkItem work)
{
#if PORTABLE
if (work != null)
work.Execute();
#else
if (_topLevelWorkItem != null)
work.Execute();
else
{
_topLevelWorkItem = work;
_runnerThread = new Thread(RunnerThreadProc);
#if !NETCF && !SILVERLIGHT
if (work.TargetApartment == ApartmentState.STA)
_runnerThread.SetApartmentState(ApartmentState.STA);
#endif
_runnerThread.Start();
}
#endif
}
/// <summary>
/// Dispatch a single work item for execution. The first
/// work item dispatched is saved as the top-level
/// work item and a thread is created on which to
/// run it. Subsequent calls come from the top level
/// item or its descendants on the proper thread.
/// </summary>
/// <param name="work">The item to dispatch</param>
public void Dispatch(WorkItem work)
{
if (_topLevelWorkItem != null)
{
work.Execute();
}
else
{
_topLevelWorkItem = work;
_runnerThread = new Thread(RunnerThreadProc);
_runnerThread.Start();
}
}
// Separate method so it can be used by Start
private async Task Dispatch(WorkItem work, ParallelExecutionStrategy strategy)
{
log.Debug("Using {0} strategy for {1}", strategy, work.Name);
// Currently, we only track CompositeWorkItems - this could be expanded
var composite = work as CompositeWorkItem;
if (composite != null)
{
lock (_activeWorkItems)
{
_activeWorkItems.Add(composite);
composite.Completed += OnWorkItemCompletion;
}
}
switch (strategy)
{
default:
case ParallelExecutionStrategy.Direct:
await work.Execute();
break;
case ParallelExecutionStrategy.Parallel:
if (work.TargetApartment == ApartmentState.STA)
{
ParallelSTAQueue.Enqueue(work);
}
else
{
ParallelQueue.Enqueue(work);
}
break;
case ParallelExecutionStrategy.NonParallel:
if (work.TargetApartment == ApartmentState.STA)
{
NonParallelSTAQueue.Enqueue(work);
}
else
{
NonParallelQueue.Enqueue(work);
}
break;
}
}
private async Task TestWorkerThreadProc()
{
_running = true;
try
{
while (_running)
{
_currentWorkItem = WorkQueue.Dequeue();
if (_currentWorkItem == null)
{
break;
}
log.Info("{0} executing {1}", _workerThread.Name, _currentWorkItem.Name);
_currentWorkItem.TestWorker = this;
// During this Busy call, the queue state may be saved.
// This gives us a new set of queues, which are initially
// empty. The intention is that only children of the current
// executing item should make use of the new set of queues.
// TODO: If we had a separate NonParallelTestWorker, it
// could simply create the isolated queue without any
// worrying about competing workers.
Busy(this, _currentWorkItem);
// Because we execute the current item AFTER the queue state
// is saved, its children end up in the new queue set.
await _currentWorkItem.Execute();
// This call may result in the queues being restored. There
// is a potential race condition here. We should not restore
// the queues unless all child items have finished.
Idle(this, _currentWorkItem);
++_workItemCount;
}
}
finally
{
log.Info("{0} stopping - {1} WorkItems processed.", Name, _workItemCount);
}
}
private void TestWorkerThreadProc()
{
log.Info("{0} starting ", _workerThread.Name);
_running = true;
try
{
while (_running)
{
_currentWorkItem = _readyQueue.Dequeue();
if (_currentWorkItem == null)
{
break;
}
log.Info("{0} executing {1}", _workerThread.Name, _currentWorkItem.Test.Name);
if (Busy != null)
{
Busy(this, EventArgs.Empty);
}
_currentWorkItem.WorkerId = Name;
_currentWorkItem.Execute();
if (Idle != null)
{
Idle(this, EventArgs.Empty);
}
++_workItemCount;
}
}
finally
{
log.Info("{0} stopping - {1} WorkItems processed.", _workerThread.Name, _workItemCount);
}
}
private void TestWorkerThreadProc()
{
log.Info("{0} starting ", _workerThread.Name);
_running = true;
try
{
while (_running)
{
_currentWorkItem = _readyQueue.Dequeue();
if (_currentWorkItem == null)
break;
log.Info("{0} executing {1}", _workerThread.Name, _currentWorkItem.Test.Name);
if (Busy != null)
Busy(this, EventArgs.Empty);
_currentWorkItem.WorkerId = Name;
_currentWorkItem.Execute();
if (Idle != null)
Idle(this, EventArgs.Empty);
++_workItemCount;
}
}
finally
{
log.Info("{0} stopping - {1} WorkItems processed.", _workerThread.Name, _workItemCount);
}
}
private void RunnerThreadProc()
{
_topLevelWorkItem.Execute();
}
private Task RunnerThreadProc()
{
return(_topLevelWorkItem.Execute());
}
private void Execute(WorkItem work)
{
log.Debug("Directly executing {0}", work.Test.Name);
work.Execute();
}
public static ITestResult ExecuteWorkItem(WorkItem work)
{
work.Execute();
// TODO: Replace with an event - but not while method is static
while (work.State != WorkItemState.Complete)
{
#if PORTABLE
System.Threading.Tasks.Task.Delay(1);
#else
Thread.Sleep(1);
#endif
}
return work.Result;
}
public void Dispatch(WorkItem work)
{
work.Execute();
}
private void Execute(WorkItem work)
{
log.Debug("Directly executing {0}", work.Test.Name);
work.Execute();
}
