public void Test_One_Thread_Created()
{
// Arrange
pcQueue = new PCQueueKnownDequeued();
progressManager = new ProgressManager();
constituencyList = new ConstituencyList();
testedClass = new TestedClass("CONSUMER", pcQueue, constituencyList, progressManager);
var expectedThreadCount = 1;
// Act
// Wait a few milliseconds to allow Consumer thread to start up
Thread.Sleep(5000);
// During this time the Consumer should have started as a single thread and incremented the running thread
// count by one
var actualThreadCount = TestedClass.RunningThreads;
// Signal Consumer thread to finish
testedClass.Finished = true;
// Allow a short period of time for the Consumer to finish
Thread.Sleep(1000);
// Assert
Assert.AreEqual(expectedThreadCount, actualThreadCount);
}
public void TestsCleanup()
{
testedClass = null;
progressManager = null;
constituencyList = null;
pcQueue = null;
}
/// <summary>
/// Инициализирует новый экземпляр класса <see cref="Producer"/>.
/// </summary>
/// <param name="errorHandler">Обработчик ошибок.</param>
/// <param name="pcQueue">Очередь Producer-Consumer.</param>
public Producer(IErrorHandler <string> errorHandler, IPCQueue <string> pcQueue)
{
_errorHandler = errorHandler
?? throw new ArgumentNullException(nameof(errorHandler));
_pcQueue = pcQueue
?? throw new ArgumentNullException(nameof(pcQueue));
}
/// <summary>
/// Constructor taking in four parameters
/// </summary>
/// <param name="id">id parameter</param>
/// <param name="pcQueue">parameter for IPCQueue</param>
/// <param name="constituencyList">parameter of ConstituencyList</param>
/// <param name="progManager">parameter of ProgressManager</param>
public Consumer(string id, IPCQueue pcQueue, ConstituencyList constituencyList, ProgressManager progManager)
{
this.id = id;
finished = false; // Initially not finished
this.pcQueue = pcQueue;
this.constituencyList = constituencyList;
this.progManager = progManager;
(T = new Thread(run)).Start(); // Create a new thread for this consumer and get it started
RunningThreads++; // Increment the number of running consumer threads;
}
/// <summary>
/// constructor passing in four parameters
/// </summary>
/// <param name="id">id parameter</param>
/// <param name="pcQueue">parameter for IPCQueue</param>
/// <param name="configFile">parameter for ConfigData</param>
/// <param name="IOhandler">paraemter for IConstituencyFileReader</param>
public Producer(string id, IPCQueue pcQueue, ConfigData configFile, IConstituencyFileReader IOhandler)
{
this.id = id;
finished = false; // Initially not finished
this.pcQueue = pcQueue;
//counter = 0; // Initial value for the work item counter]
this.configFile = configFile;
this.IOhandler = IOhandler;
(T = new Thread(run)).Start(); // Create a new thread for this producer and get it started
RunningThreads++; // Increment the number of running producer threads;
}
/// <summary>
/// Инициализирует новый экземпляр класса <see cref="Consumer"/>.
/// </summary>
/// <param name="errorHandler">Обработчик ошибок.</param>
/// <param name="fileHandler">Обработчик файлов.</param>
/// <param name="resultHandler">Обработчик результатов.</param>
/// <param name="pcQueue">Очередь Producer-Consumer.</param>
public Consumer(
IErrorHandler <string> errorHandler,
IFileHandler <Result <ulong> > fileHandler,
IResultHandler <ConsumerResult> resultHandler,
IPCQueue <string> pcQueue)
{
_errorHandler = errorHandler
?? throw new ArgumentNullException(nameof(errorHandler));
_fileHandler = fileHandler
?? throw new ArgumentNullException(nameof(fileHandler));
_resultHandler = resultHandler
?? throw new ArgumentNullException(nameof(resultHandler));
_pcQueue = pcQueue
?? throw new ArgumentNullException(nameof(pcQueue));
}
public void Test_Run_Method_Null_Dequeued_Expect_No_ProgressManager_Accesses()
{
// Arrange
pcQueue = new PCQueueNullDequeued();
progressManager = new ProgressManager();
constituencyList = new ConstituencyList();
testedClass = new TestedClass("Consumer", pcQueue, constituencyList, progressManager);
// Act
// Wait a few seconds to allow Consumer thread to run for a short period, during this time the Consumer will
// have dequeued a number of nulls each of which should be ignored, we do not know how many though and it does not
// matter (if it works for one it works for all)
Thread.Sleep(5000);
// Signal Consumer thread to finish
testedClass.Finished = true;
// Allow a short period of time for the Consumer to finish
Thread.Sleep(1000);
// Assert
// There should be no accesses of the ProgressManager
Assert.AreEqual(0, Math.Abs(progressManager.ItemsRemaining));
}
public void Test_Run_Method_Constituency_Created_Equals_Progress_Mananger_Accesses()
{
// Arrange
pcQueue = new PCQueueKnownDequeued();
progressManager = new ProgressManager();
constituencyList = new ConstituencyList();
testedClass = new TestedClass("Consumer", pcQueue, constituencyList, progressManager);
// Act
// Wait a few milliseconds to allow Consumer thread to run for a short period, during this time the Consumer will
// have created as many constituency as progress manager accesses, we do not know how many though
Thread.Sleep(5000);
// Signal Consumer thread to finish
testedClass.Finished = true;
// Allow a short period of time for the Consumer to finish
Thread.Sleep(1000);
// Assert
// Expected ProgressManager accesses can be determined by the abs value of the ItemsRemaining property, one of these
// for each time a constituency is added to the constituencylist
Assert.AreEqual(Math.Abs(progressManager.ItemsRemaining), constituencyList.constituency.Count);
}
/// <summary>
/// Инициализирует новый экземпляр класса <see cref="PCController"/>.
/// </summary>
/// <param name="errorHandler">Обработчик ошибок.</param>
/// <param name="producer">Поставщик заданий на работу.</param>
/// <param name="consumer">Исполнитель.</param>
/// <param name="pcQueue">Очередь Producer-Consumer.</param>
/// <param name="settings">Настройки приложения.</param>
public PCController(
IErrorHandler <string> errorHandler,
IProducer <string> producer,
IConsumer consumer,
IPCQueue <string> pcQueue,
Settings settings)
{
_errorHandler = errorHandler
?? throw new ArgumentNullException(nameof(errorHandler));
_producer = producer
?? throw new ArgumentNullException(nameof(producer));
_consumer = consumer
?? throw new ArgumentNullException(nameof(consumer));
_pcQueue = pcQueue
?? throw new ArgumentNullException(nameof(pcQueue));
_settings = settings
?? throw new ArgumentNullException(nameof(settings));
InitializeTasks(settings.MaxNumberOfParallelTasks);
}
