SystemExtensions/SystemExtensions.Tests/Threading/PriorityThreadPoolTests.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using static System.Threading.PriorityThreadPool;

namespace System.Threading.Tests;

[TestClass()]
public class PriorityThreadPoolTests
{
    private static PriorityThreadPool threadPool = new PriorityThreadPool();
    private static int lowest = 0, belowAverage = 0, 
        normal = 0, aboveAverage = 0, highest = 0;
    [TestMethod()]
    public void PriorityThreadPoolTest()
    {
        threadPool.Dispose();
        threadPool = new PriorityThreadPool();
        if (threadPool.NumberOfThreads != Environment.ProcessorCount)
        {
            Assert.Fail();
        }
    }

    [TestMethod()]
    public void PriorityThreadPoolTest1()
    {
        threadPool.Dispose();
        threadPool = new PriorityThreadPool(4);
        if (threadPool.NumberOfThreads != 4)
        {
            Assert.Fail();
        }
    }

    [TestMethod()]
    public void PriorityThreadPoolTest2()
    {
        threadPool.Dispose();
        threadPool = new PriorityThreadPool(1, 1, 1, 1, 1);
        if (threadPool.NumberOfThreads != 5)
        {
            Assert.Fail();
        }
    }

    [TestMethod()]
    public void DisposeTest()
    {
        threadPool.Dispose();
        Thread.Sleep(100);
        try
        {
            var x = threadPool.NumberOfThreads;
            Assert.Fail();
        }
        catch (Exception)
        {
            
        }
    }

    [TestMethod()]
    public void DefaultQueueTest()
    {
        threadPool.Dispose();
        threadPool = new PriorityThreadPool();
        for (var i = 0; i < 10; i++)
        {
            threadPool.QueueUserWorkItem(o =>
            {
                for (var x = 0; x < 100; x++)
                {
                    System.Diagnostics.Debug.WriteLine(Thread.CurrentThread.ManagedThreadId + " - " + x);
                }
            }, null);
        }

        for (var i = 0; i < 10; i++)
        {
            System.Diagnostics.Debug.WriteLine("=====================================");
            System.Diagnostics.Debug.WriteLine("Current threads in threadpool: " + threadPool.NumberOfThreads);
            System.Diagnostics.Debug.WriteLine("=====================================");
            Thread.Sleep(100);
        }

        while (threadPool.NumberOfThreads != System.Environment.ProcessorCount / 4)
        {
            System.Diagnostics.Debug.WriteLine("=====================================");
            System.Diagnostics.Debug.WriteLine("Current threads in threadpool: " + threadPool.NumberOfThreads);
            System.Diagnostics.Debug.WriteLine("=====================================");
            Thread.Sleep(100);
        }
    }

    [TestMethod()]
    public void QueueTestWith4MaxThreads()
    {
        threadPool.Dispose();
        threadPool = new PriorityThreadPool(4);
        if (threadPool.NumberOfThreads != 4)
        {
            Assert.Fail();
        }

        for (var i = 0; i < 10; i++)
        {
            threadPool.QueueUserWorkItem(o =>
            {
                for (var x = 0; x < 100; x++)
                {
                    System.Diagnostics.Debug.WriteLine(Thread.CurrentThread.ManagedThreadId + " - " + x);
                }
            }, null);
        }

        while (threadPool.NumberOfThreads != 1)
        {
            System.Diagnostics.Debug.WriteLine("=====================================");
            System.Diagnostics.Debug.WriteLine("Current threads in threadpool: " + threadPool.NumberOfThreads);
            System.Diagnostics.Debug.WriteLine("=====================================");
            Thread.Sleep(100);
        }
    }

    [TestMethod()]
    public void QueueTestWith5ManualThreads()
    {
        threadPool.Dispose();
        threadPool = new PriorityThreadPool(1, 1, 1, 1, 1);
        if (threadPool.NumberOfThreads != 5)
        {
            Assert.Fail();
        }

        for (var i = 0; i < 10; i++)
        {
            threadPool.QueueUserWorkItem(o =>
            {
                for (var x = 0; x < 100; x++)
                {
                    switch (Thread.CurrentThread.Priority)
                    {
                        case ThreadPriority.Lowest:
                            lowest++;
                            break;
                        case ThreadPriority.BelowNormal:
                            belowAverage++;
                            break;
                        case ThreadPriority.Normal:
                            normal++;
                            break;
                        case ThreadPriority.AboveNormal:
                            aboveAverage++;
                            break;
                        case ThreadPriority.Highest:
                            highest++;
                            break;
                    }
                }
            }, null);
        }

        for (var i = 0; i < 50; i++)
        {
            System.Diagnostics.Debug.WriteLine("=====================================");
            System.Diagnostics.Debug.WriteLine("Current threads in threadpool: " + threadPool.NumberOfThreads);
            System.Diagnostics.Debug.WriteLine("=====================================");
            Thread.Sleep(100);
        }

        System.Diagnostics.Debug.WriteLine("\nL: " + lowest + "\nBN: " + belowAverage + "\nN: " + normal + "\nAN:" + aboveAverage + "\nH: " + highest);
    }

    [TestMethod()]
    public void QueueTestWithDifferentPriorityTasks()
    {
        threadPool.Dispose();
        threadPool = new PriorityThreadPool();
        for (var i = 0; i < 1000; i++)
        {
            var taskPriority = TaskPriority.Lowest;
            if(i % 10 == 0)
            {
                taskPriority = TaskPriority.Highest;
            }
            else if(i % 5 == 0)
            {
                taskPriority = TaskPriority.Normal;
            }
            else if(i % 2 == 0)
            {
                taskPriority = TaskPriority.BelowNormal;
            }

            threadPool.QueueUserWorkItem(o =>
            {
                System.Diagnostics.Debug.WriteLine(Thread.CurrentThread.ManagedThreadId + " - " + taskPriority);
            }, null, taskPriority);
        }

        while (threadPool.NumberOfThreads != System.Environment.ProcessorCount / 4)
        {
            System.Diagnostics.Debug.WriteLine("=====================================");
            System.Diagnostics.Debug.WriteLine("Current threads in threadpool: " + threadPool.NumberOfThreads);
            System.Diagnostics.Debug.WriteLine("=====================================");
            Thread.Sleep(100);
        }
    }
}