ThreadPoolTest.java

package com.taskscheduler;

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class ThreadPoolTest {

    private ThreadPool pool;

    @BeforeEach
    void setUp() {
        pool = new ThreadPool(3, 20);
    }

    @AfterEach
    void tearDown() {
        if (!pool.isShutdown()) {
            pool.shutdown();
        }
    }

    @Test
    @Order(1)
    @DisplayName("Tasks are executed by worker threads")
    void testTasksAreExecuted() throws InterruptedException {
        AtomicInteger counter = new AtomicInteger(0);
        CountDownLatch latch = new CountDownLatch(5);

        for (int i = 0; i < 5; i++) {
            pool.submit("Task-" + i, () -> {
                counter.incrementAndGet();
                latch.countDown();
            });
        }

        assertTrue(latch.await(3, TimeUnit.SECONDS), "All tasks should complete within 3s");
        assertEquals(5, counter.get());
    }

    @Test
    @Order(2)
    @DisplayName("Stats track completed tasks correctly")
    void testStatsTracking() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            pool.submit("StatTask-" + i, () -> {
                try { Thread.sleep(50); } catch (InterruptedException e) {}
                latch.countDown();
            });
        }

        latch.await(3, TimeUnit.SECONDS);
        Thread.sleep(100); // allow stats to settle

        assertEquals(3, pool.getStats().getTotalCompleted());
        assertEquals(0, pool.getStats().getTotalFailed());
    }

    @Test
    @Order(3)
    @DisplayName("Failed tasks are recorded in stats")
    void testFailedTaskStats() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);

        pool.submit("FailingTask", () -> {
            latch.countDown();
            throw new RuntimeException("Intentional failure");
        });

        latch.await(3, TimeUnit.SECONDS);
        Thread.sleep(100);

        assertEquals(1, pool.getStats().getTotalFailed());
    }

    @Test
    @Order(4)
    @DisplayName("High priority tasks have higher priority level than low")
    void testTaskPriorityOrdering() {
        Task low    = new Task("Low",  () -> {}, Task.Priority.LOW);
        Task medium = new Task("Med",  () -> {}, Task.Priority.MEDIUM);
        Task high   = new Task("High", () -> {}, Task.Priority.HIGH);

        // High should come before medium and low (compareTo returns negative = comes first)
        assertTrue(high.compareTo(low) < 0);
        assertTrue(high.compareTo(medium) < 0);
        assertTrue(medium.compareTo(low) < 0);
    }

    @Test
    @Order(5)
    @DisplayName("Pool rejects tasks after shutdown")
    void testRejectionAfterShutdown() throws InterruptedException {
        pool.shutdown();
        boolean accepted = pool.submit("LateTask", () -> {});
        assertFalse(accepted, "Pool should reject tasks after shutdown");
    }

    @Test
    @Order(6)
    @DisplayName("Queue rejects tasks when at capacity")
    void testQueueCapacity() {
        ThreadPool smallPool = new ThreadPool(1, 3);

        // Flood with slow tasks to fill the queue
        for (int i = 0; i < 10; i++) {
            smallPool.submit("Task-" + i, () -> {
                try { Thread.sleep(500); } catch (InterruptedException e) {}
            });
        }

        // Queue should be bounded — not all tasks accepted
        assertTrue(smallPool.getQueueSize() <= 3);
        smallPool.shutdownNow();
    }

    @Test
    @Order(7)
    @DisplayName("Multiple tasks execute concurrently across workers")
    void testConcurrentExecution() throws InterruptedException {
        AtomicInteger concurrent = new AtomicInteger(0);
        AtomicInteger maxConcurrent = new AtomicInteger(0);
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            pool.submit("ConcurrentTask-" + i, () -> {
                int current = concurrent.incrementAndGet();
                maxConcurrent.updateAndGet(max -> Math.max(max, current));
                try { Thread.sleep(200); } catch (InterruptedException e) {}
                concurrent.decrementAndGet();
                latch.countDown();
            });
        }

        latch.await(3, TimeUnit.SECONDS);
        assertTrue(maxConcurrent.get() > 1, "Tasks should run concurrently");
    }
}