using Microsoft.VisualStudio.TestTools.UnitTesting;

using System;

using System.IO;

using System.Threading;

​

public class DiningPhilosophers

{

    private static Mutex[] forks;

    private static Thread[] philosophers;

    private static int numPhilosophers;

    private static Random random = new Random();

​

    /// <summary>

    /// Print the DiningPhilosopher's status.

    /// </summary>

    /// <param name="n">The number of Philosophers.</param>

    public void DiningPhilosopher(int n)

    {

        numPhilosophers = n;

        forks = new Mutex[numPhilosophers];

        philosophers = new Thread[numPhilosophers];

​

        for (int i = 0; i < numPhilosophers; i++)

        {

            forks[i] = new Mutex();

        }

​

        for (int i = 0; i < numPhilosophers; i++)

        {

            int philosopherId = i; // Capture the loop variable

            philosophers[i] = new Thread(() => Philosopher(philosopherId));

            philosophers[i].Name = "Philosopher " + i;

            philosophers[i].Start();

        }

​

        // Keep the simulation running for a while (e.g., 10 seconds)

        Thread.Sleep(10000);

​

        // Abort the threads to end the simulation

        foreach (Thread philosopher in philosophers)

        {

            philosopher.Abort();

        }

​

        Console.WriteLine("Simulation ended.");

    }

​

    static void Philosopher(int id)

    {

        int leftFork = id;

        int rightFork = (id + 1) % numPhilosophers;

​

        try

        {

            while (true)

            {

                // Think

                Console.WriteLine($"{Thread.CurrentThread.Name} is thinking.");

                Thread.Sleep(random.Next(100, 500));

​

                // Try to acquire forks

                Console.WriteLine($"{Thread.CurrentThread.Name} is hungry.");

                if (forks[leftFork].WaitOne(100)) // Try to pick up left fork

                {

                    Console.WriteLine($"{Thread.CurrentThread.Name} picked up left fork.");

                    if (forks[rightFork].WaitOne(100)) // Try to pick up right fork

                    {

                        Console.WriteLine($"{Thread.CurrentThread.Name} picked up right fork and is eating.");

                        Thread.Sleep(random.Next(100, 500)); // Eat

​

                        forks[rightFork].ReleaseMutex();

                        Console.WriteLine($"{Thread.CurrentThread.Name} put down right fork.");

                    }

                    else

                    {

                        Console.WriteLine($"{Thread.CurrentThread.Name} could not get right fork, returning left fork.");

                        forks[leftFork].ReleaseMutex();

                        Console.WriteLine($"{Thread.CurrentThread.Name} put down left fork.");

                        Thread.Sleep(random.Next(50, 200)); // Avoid immediate retry

                        continue;

                    }

​

                    forks[leftFork].ReleaseMutex();

                    Console.WriteLine($"{Thread.CurrentThread.Name} put down left fork.");

​

                    //break; // Back to thinking

​

                }

                else

                {

                    Console.WriteLine($"{Thread.CurrentThread.Name} could not get left fork, waiting.");

                    Thread.Sleep(random.Next(50, 200)); //Avoid immediate retry

                }

            }

        }

        catch (ThreadAbortException)

        {

            Console.WriteLine($"{Thread.CurrentThread.Name} simulation aborted.");

        }

        finally

        {

            if (forks[leftFork].WaitOne(0))

            {

                forks[leftFork].ReleaseMutex();

            }

            if (forks[rightFork].WaitOne(0))

            {

                forks[rightFork].ReleaseMutex();

            }

        }

    }

}

[TestClass]

public class DiningPhilosophersTests

{

    [TestMethod]

    public void DiningPhilosopher_ValidInput_RunsWithoutDeadlock()

    {

        // Arrange

        int numPhilosophers = 5;

        DiningPhilosophers dp = new DiningPhilosophers();

        StringWriter consoleOutput = new StringWriter();

        Console.SetOut(consoleOutput);

​

        // Act

        try

        {

            dp.DiningPhilosopher(numPhilosophers);

        }

        catch (Exception ex)

        {

            Assert.Fail("Exception thrown during execution: " + ex.Message);

        }

​

        // Assert:  The main assertion is that the code runs without a deadlock 

        // within the time limit set in the DiningPhilosopher method.  We also check

        // that some output was generated, indicating that the philosophers

        // were at least attempting to eat.

        string output = consoleOutput.ToString();

        Assert.IsFalse(string.IsNullOrEmpty(output), "No output was produced.  Possible deadlock?");

​

        // Restore console output

        Console.SetOut(Console.Out);

    }

​

    [TestMethod]

    [ExpectedException(typeof(ThreadAbortException))]

    public void DiningPhilosopher_ZeroPhilosophers_NoException()

    {

        //Arrange

        int numPhilosophers = 0;

        DiningPhilosophers dp = new DiningPhilosophers();

​

        //Act

        dp.DiningPhilosopher(numPhilosophers);

​

        //Assert: Should throw ThreadAbortException because simulation ended

    }

}