/// <summary>
/// Assign a worker to the shift.
/// </summary>
/// <param name="worker"></param>
public void Assign(TestWorker worker)
{
log.Debug("{0} shift assigned worker {1}", _name, worker.Name);
Workers.Add(worker);
worker.Busy += (s, ea) => Interlocked.Increment(ref _busyCount);
worker.Idle += (s, ea) =>
{
// Quick check first using Interlocked.Decrement
if (Interlocked.Decrement(ref _busyCount) == 0)
{
lock (_syncRoot)
{
// Check busy count again under the lock
if (_busyCount == 0 && !HasWork)
{
this.EndShift();
}
}
}
};
worker.Start();
}
public void StopQueue_WithWorkers()
{
var workers = new TestWorker[] {
new TestWorker(_queue, "1", ApartmentState.MTA),
new TestWorker(_queue, "2", ApartmentState.MTA),
new TestWorker(_queue, "3", ApartmentState.MTA)
};
foreach (var worker in workers)
{
worker.Start();
Assert.That(worker.IsAlive, "Worker thread {0} did not start", worker.Name);
}
_queue.Start();
_queue.Stop();
Assert.That(_queue.State, Is.EqualTo(WorkItemQueueState.Stopped));
Thread.Sleep(20); // Allow time for workers to stop
foreach (var worker in workers)
{
Assert.False(worker.IsAlive, "Worker thread {0} did not stop", worker.Name);
}
}
private void InitializeShifts()
{
foreach (var shift in Shifts)
{
shift.EndOfShift += OnEndOfShift;
}
// Assign queues to shifts
ParallelShift.AddQueue(ParallelQueue);
ParallelShift.AddQueue(ParallelSTAQueue);
NonParallelShift.AddQueue(NonParallelQueue);
NonParallelSTAShift.AddQueue(NonParallelSTAQueue);
// Create workers and assign to shifts and queues
// TODO: Avoid creating all the workers till needed
for (int i = 1; i <= LevelOfParallelism; i++)
{
string name = string.Format("ParallelWorker#" + i.ToString());
ParallelShift.Assign(new TestWorker(ParallelQueue, name));
}
ParallelShift.Assign(new TestWorker(ParallelSTAQueue, "ParallelSTAWorker"));
var worker = new TestWorker(NonParallelQueue, "NonParallelWorker");
worker.Busy += OnStartNonParallelWorkItem;
NonParallelShift.Assign(worker);
worker = new TestWorker(NonParallelSTAQueue, "NonParallelSTAWorker");
worker.Busy += OnStartNonParallelWorkItem;
NonParallelSTAShift.Assign(worker);
}
private void OnStartNonParallelWorkItem(TestWorker worker, WorkItem work)
{
if (work is CompositeWorkItem)
{
SaveQueueState(work);
}
}
private void OnStartNonParallelWorkItem(TestWorker worker, WorkItem work)
{
// This captures the startup of TestFixtures and SetUpFixtures,
// but not their teardown items, which are not composite items
if (work.IsolateChildTests)
{
IsolateQueues(work);
}
}
public void SetUp()
{
_queue = new WorkItemQueue("TestQ");
#if NETCF
_worker = new TestWorker(_queue, "TestQ_Worker");
#else
_worker = new TestWorker(_queue, "TestQ_Worker", ApartmentState.MTA);
#endif
}
public void SetUp()
{
#if APARTMENT_STATE
_queue = new WorkItemQueue("TestQ", true, ApartmentState.MTA);
#else
_queue = new WorkItemQueue("TestQ", true);
#endif
_worker = new TestWorker(_queue, "TestQ_Worker");
}
private void OnStartNonParallelWorkItem(TestWorker worker, WorkItem work)
{
// This captures the startup of TestFixtures and SetUpFixtures,
// but not their teardown items, which are not composite items
if (work is CompositeWorkItem && work.Test.TypeInfo != null)
{
IsolateQueues(work);
}
}
public void SetUp()
{
_queue = new WorkItemQueue("TestQ");
#if NETCF
_worker = new TestWorker(_queue, "TestQ_Worker");
#else
_worker = new TestWorker(_queue, "TestQ_Worker", ApartmentState.MTA);
#endif
}
public void StopQueue_WithWorkers()
{
var workers = new TestWorker[]
{
new TestWorker(_queue, "1"),
new TestWorker(_queue, "2"),
new TestWorker(_queue, "3")
};
foreach (var worker in workers)
{
worker.Start();
Assert.That(worker.IsAlive, "Worker thread {0} did not start", worker.Name);
}
_queue.Start();
_queue.Stop();
Assert.That(_queue.State, Is.EqualTo(WorkItemQueueState.Stopped));
int iters = 10;
int alive = workers.Length;
while (iters-- > 0 && alive > 0)
{
Thread.Sleep(60); // Allow time for workers to stop
alive = 0;
foreach (var worker in workers)
{
if (worker.IsAlive)
{
alive++;
}
}
}
if (alive > 0)
{
foreach (var worker in workers)
{
Assert.False(worker.IsAlive, "Worker thread {0} did not stop", worker.Name);
}
}
}
public void StopQueue_WithWorkers()
{
var workers = new TestWorker[] {
new TestWorker(_queue, "1", ApartmentState.MTA),
new TestWorker(_queue, "2", ApartmentState.MTA),
new TestWorker(_queue, "3", ApartmentState.MTA)
};
foreach (var worker in workers)
{
worker.Start();
Assert.That(worker.IsAlive, "Worker thread {0} did not start", worker.Name);
}
_queue.Start();
_queue.Stop();
Assert.That(_queue.State, Is.EqualTo(WorkItemQueueState.Stopped));
Thread.Sleep(20); // Allow time for workers to stop
foreach (var worker in workers)
Assert.False(worker.IsAlive, "Worker thread {0} did not stop", worker.Name);
}
/// <summary>
/// Construct a ParallelWorkItemDispatcher
/// </summary>
/// <param name="levelOfParallelism">Number of workers to use</param>
public ParallelWorkItemDispatcher(int levelOfParallelism)
{
// Create Shifts
ParallelShift = new WorkShift("Parallel");
NonParallelShift = new WorkShift("NonParallel");
NonParallelSTAShift = new WorkShift("NonParallelSTA");
foreach (var shift in Shifts)
{
shift.EndOfShift += OnEndOfShift;
}
// Assign queues to shifts
ParallelShift.AddQueue(ParallelQueue);
ParallelShift.AddQueue(ParallelSTAQueue);
NonParallelShift.AddQueue(NonParallelQueue);
NonParallelSTAShift.AddQueue(NonParallelSTAQueue);
// Create workers and assign to shifts and queues
// TODO: Avoid creating all the workers till needed
for (int i = 1; i <= levelOfParallelism; i++)
{
string name = string.Format("Worker#" + i.ToString());
ParallelShift.Assign(new TestWorker(ParallelQueue, name));
}
ParallelShift.Assign(new TestWorker(ParallelSTAQueue, "Worker#STA"));
var worker = new TestWorker(NonParallelQueue, "Worker#STA_NP");
worker.Busy += OnStartNonParallelWorkItem;
NonParallelShift.Assign(worker);
worker = new TestWorker(NonParallelSTAQueue, "Worker#NP_STA");
worker.Busy += OnStartNonParallelWorkItem;
NonParallelSTAShift.Assign(worker);
}
/// <summary>
/// Assign a worker to this shift. The worker is already
/// associated with a queue, which must be one of those
/// owned by the shift.
/// </summary>
/// <param name="worker"></param>
public void Assign(TestWorker worker)
{
_workers.Add(worker);
worker.Busy += (s, ea) => { Interlocked.Increment(ref _busyCount); };
worker.Idle += (s, ea) =>
{
// Quick check first
if (Interlocked.Decrement(ref _busyCount) == 0)
{
lock (_syncRoot)
{
// Double-check that all workers are idle
if (_busyCount > 0)
{
return;
}
// Check that the queues are empty
foreach (var q in _queues)
{
if (!q.IsEmpty)
{
return;
}
}
// End the shift
this.Pause();
// Signal the dispatcher
if (EndOfShift != null)
{
EndOfShift(this, EventArgs.Empty);
}
}
}
};
worker.Start();
}
public void StopQueue_WithWorkers()
{
var workers = new TestWorker[]
{
new TestWorker(_queue, "1", ApartmentState.MTA),
new TestWorker(_queue, "2", ApartmentState.MTA),
new TestWorker(_queue, "3", ApartmentState.MTA)
};
foreach (var worker in workers)
{
worker.Start();
Assert.That(worker.IsAlive, "Worker thread {0} did not start", worker.Name);
}
_queue.Start();
_queue.Stop();
Assert.That(_queue.State, Is.EqualTo(WorkItemQueueState.Stopped));
int iters = 10;
int alive = workers.Length;
while (iters-- > 0 && alive > 0)
{
Thread.Sleep(60); // Allow time for workers to stop
alive = 0;
foreach (var worker in workers)
if (worker.IsAlive)
alive++;
}
if (alive > 0)
foreach (var worker in workers)
Assert.False(worker.IsAlive, "Worker thread {0} did not stop", worker.Name);
}
public void SetUp()
{
_queue = new WorkItemQueue("TestQ");
_worker = new TestWorker(_queue, "TestQ_Worker", ApartmentState.MTA);
}
/// <summary>
/// Assign a worker to the shift.
/// </summary>
/// <param name="worker"></param>
public void Assign(TestWorker worker)
{
log.Debug("{0} shift assigned worker {1}", Name, worker.Name);
Workers.Add(worker);
}
public void SetUp()
{
_queue = new WorkItemQueue("TestQ");
_worker = new TestWorker(_queue, "TestQ_Worker", ApartmentState.MTA);
}
/// <summary>
/// Assign a worker to the shift.
/// </summary>
/// <param name="worker"></param>
public void Assign(TestWorker worker)
{
log.Debug("{0} shift assigned worker {1}", _name, worker.Name);
Workers.Add(worker);
worker.Busy += (s, ea) => Interlocked.Increment(ref _busyCount);
worker.Idle += (s, ea) =>
{
// Quick check first using Interlocked.Decrement
if (Interlocked.Decrement(ref _busyCount) == 0)
lock (_syncRoot)
{
// Check busy count again under the lock
if (_busyCount == 0 && !HasWork)
this.EndShift();
}
};
worker.Start();
}
/// <summary>
/// Assign a worker to this shift. The worker is already
/// associated with a queue, which must be one of those
/// owned by the shift.
/// </summary>
/// <param name="worker"></param>
public void Assign(TestWorker worker)
{
_workers.Add(worker);
worker.Busy += (s, ea) => { Interlocked.Increment(ref _busyCount); };
worker.Idle += (s, ea) =>
{
// Quick check first
if (Interlocked.Decrement(ref _busyCount) == 0)
lock (_syncRoot)
{
// Double-check that all workers are idle
if (_busyCount > 0)
return;
// Check that the queues are empty
foreach (var q in _queues)
if (!q.IsEmpty)
return;
// End the shift
this.Pause();
// Signal the dispatcher
if (EndOfShift != null)
EndOfShift(this, EventArgs.Empty);
}
};
worker.Start();
}
