527691 Step2 UnitTest | C# Online Compiler

527691 Step2 UnitTest by AdityaTuring

using System;
using System.Collections.Generic;
using NUnit.Framework;

public class DroneDelivery
{
    public static int FindMinimumDeliveryTime(
        List<Tuple<int, int, int>> flightPaths,
        HashSet<int> processingCenters,
        int source,
        int destination,
        int processingDelay)
    {
        // Input validation
        if (flightPaths == null || processingCenters == null)
        {
            throw new ArgumentNullException("Flight paths or processing centers cannot be null.");
        }

        if (processingDelay < 0)
        {
            throw new ArgumentException("Processing delay cannot be negative.");
        }

        // Build the graph (adjacency list)
        Dictionary<int, List<Tuple<int, int>>> graph = new Dictionary<int, List<Tuple<int, int>>>();
        foreach (var path in flightPaths)
        {
            if (!graph.ContainsKey(path.Item1))
            {
                graph[path.Item1] = new List<Tuple<int, int>>();
            }
            graph[path.Item1].Add(Tuple.Create(path.Item2, path.Item3)); // Destination hub, travel time
        }

        // Initialize distances
        Dictionary<int, int> distances = new Dictionary<int, int>();
        foreach (var hub in graph.Keys)
        {
            distances[hub] = int.MaxValue;
        }
        distances[source] = 0;

        // Priority queue (MinHeap)
        PriorityQueue<int, int> priorityQueue = new PriorityQueue<int, int>();
        priorityQueue.Enqueue(source, 0);

        while (priorityQueue.Count > 0)
        {
            int currentHub = priorityQueue.Dequeue();

            if (!graph.ContainsKey(currentHub))
            {
                continue;
            }

            foreach (var neighbor in graph[currentHub])
            {
                int nextHub = neighbor.Item1;
                int travelTime = neighbor.Item2;
                int delay = (processingCenters.Contains(currentHub) && currentHub != source && currentHub != destination)
                    ? processingDelay
                    : 0;
                int newDist = distances[currentHub] + travelTime + delay;

                if (!distances.ContainsKey(nextHub))
                {
                    distances[nextHub] = int.MaxValue;
                }

                if (newDist < distances[nextHub])
                {
                    distances[nextHub] = newDist;
                    priorityQueue.Enqueue(nextHub, newDist);
                }
            }
        }

        return distances[destination] == int.MaxValue ? -1 : distances[destination];
    }

    [TestFixture]
    public class DroneDeliveryTests
    {
        [Test]
        public void BasicTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5),
                Tuple.Create(1, 2, 10),
                Tuple.Create(0, 3, 15),
                Tuple.Create(3, 2, 5)
            };
            HashSet<int> processingCenters = new HashSet<int> { 1, 3 };
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(18));
        }

        [Test]
        public void NoProcessingCentersTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5),
                Tuple.Create(1, 2, 10)
            };
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(15));
        }

        [Test]
        public void AllHubsProcessingCentersTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5),
                Tuple.Create(1, 2, 10)
            };
            HashSet<int> processingCenters = new HashSet<int> { 0, 1, 2 };
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(18));
        }

        [Test]
        public void NoPathTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5)
            };
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(-1));
        }

        [Test]
        public void SameSourceDestinationTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5)
            };
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 0;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(0));
        }

        [Test]
        public void LargeGraphTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>();
            for (int i = 0; i < 100; i++)
            {
                flightPaths.Add(Tuple.Create(i, i + 1, 1));
            }
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 100;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(100));
        }

        [Test]
        public void ZeroFlightTimesTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 0),
                Tuple.Create(1, 2, 0)
            };
            HashSet<int> processingCenters = new HashSet<int> { 1 };
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(3));
        }

        [Test]
        public void EmptyFlightPathsTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>();
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(-1));
        }

        [Test]
        public void NegativeProcessingDelayTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5)
            };
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 1;
            int processingDelay = -3;
            Assert.Throws<ArgumentException>(() => DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay));
        }

        [Test]
        public void NullFlightPathsTest()
        {
            List<Tuple<int, int, int>> flightPaths = null;
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 1;
            int processingDelay = 3;
            Assert.Throws<ArgumentNullException>(() => DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay));
        }

        [Test]
        public void NullProcessingCentersTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5)
            };
            HashSet<int> processingCenters = null;
            int source = 0;
            int destination = 1;
            int processingDelay = 3;
            Assert.Throws<ArgumentNullException>(() => DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay));
        }
    }

    public class PriorityQueue<T, TPriority> where TPriority : IComparable<TPriority>
    {
        private List<(T item, TPriority priority)> _elements = new List<(T item, TPriority priority)>();

        public int Count => _elements.Count;

        public void Enqueue(T item, TPriority priority)
        {
            _elements.Add((item, priority));
            _elements.Sort((x, y) => x.priority.CompareTo(y.priority));
        }

        public T Dequeue()
        {
            if (_elements.Count == 0)
            {
                throw new InvalidOperationException("Priority queue is empty.");
            }
            T item = _elements[0].item;
            _elements.RemoveAt(0);
            return item;
        }
    }

    public static void Main(string[] args)
    {
        // Instantiate the test fixture
        var tests = new DroneDeliveryTests();
        int passed = 0, failed = 0;

        // List of test methods to run
        var testMethods = new List<Action>
        {
            tests.BasicTest,
            tests.NoProcessingCentersTest,
            tests.AllHubsProcessingCentersTest,
            tests.NoPathTest,
            tests.SameSourceDestinationTest,
            tests.LargeGraphTest,
            tests.ZeroFlightTimesTest,
            tests.EmptyFlightPathsTest,
            tests.NegativeProcessingDelayTest,
            tests.NullFlightPathsTest,
            tests.NullProcessingCentersTest
        };

        // Execute each test and print the result.
        foreach (var test in testMethods)
        {
            try
            {
                test();
                Console.WriteLine($"{test.Method.Name}: Passed");
                passed++;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"{test.Method.Name}: Failed - {ex.Message}");
                failed++;
            }
        }

        Console.WriteLine($"Total tests: {passed + failed}, Passed: {passed}, Failed: {failed}");
    }
}

​x
 
using System;
using System.Collections.Generic;
using NUnit.Framework;
​
public class DroneDelivery
{
    public static int FindMinimumDeliveryTime(
        List<Tuple<int, int, int>> flightPaths,
        HashSet<int> processingCenters,
        int source,
        int destination,
        int processingDelay)
    {
        // Input validation
        if (flightPaths == null || processingCenters == null)
        {
            throw new ArgumentNullException("Flight paths or processing centers cannot be null.");
        }
​
        if (processingDelay < 0)
        {
            throw new ArgumentException("Processing delay cannot be negative.");
        }
​
        // Build the graph (adjacency list)
        Dictionary<int, List<Tuple<int, int>>> graph = new Dictionary<int, List<Tuple<int, int>>>();
        foreach (var path in flightPaths)
        {
            if (!graph.ContainsKey(path.Item1))
            {
                graph[path.Item1] = new List<Tuple<int, int>>();
            }
            graph[path.Item1].Add(Tuple.Create(path.Item2, path.Item3)); // Destination hub, travel time
        }
​
        // Initialize distances
        Dictionary<int, int> distances = new Dictionary<int, int>();
        foreach (var hub in graph.Keys)
        {
            distances[hub] = int.MaxValue;
        }
        distances[source] = 0;
​
        // Priority queue (MinHeap)
        PriorityQueue<int, int> priorityQueue = new PriorityQueue<int, int>();
        priorityQueue.Enqueue(source, 0);
​
        while (priorityQueue.Count > 0)
        {
            int currentHub = priorityQueue.Dequeue();
​
            if (!graph.ContainsKey(currentHub))
            {
                continue;
            }
​
            foreach (var neighbor in graph[currentHub])
            {
                int nextHub = neighbor.Item1;
                int travelTime = neighbor.Item2;
                int delay = (processingCenters.Contains(currentHub) && currentHub != source && currentHub != destination)
                    ? processingDelay
                    : 0;
                int newDist = distances[currentHub] + travelTime + delay;
​
                if (!distances.ContainsKey(nextHub))
                {
                    distances[nextHub] = int.MaxValue;
                }
​
                if (newDist < distances[nextHub])
                {
                    distances[nextHub] = newDist;
                    priorityQueue.Enqueue(nextHub, newDist);
                }
            }
        }
​
        return distances[destination] == int.MaxValue ? -1 : distances[destination];
    }
​
    [TestFixture]
    public class DroneDeliveryTests
    {
        [Test]
        public void BasicTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5),
                Tuple.Create(1, 2, 10),
                Tuple.Create(0, 3, 15),
                Tuple.Create(3, 2, 5)
            };
            HashSet<int> processingCenters = new HashSet<int> { 1, 3 };
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(18));
        }
​
        [Test]
        public void NoProcessingCentersTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5),
                Tuple.Create(1, 2, 10)
            };
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(15));
        }
​
        [Test]
        public void AllHubsProcessingCentersTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5),
                Tuple.Create(1, 2, 10)
            };
            HashSet<int> processingCenters = new HashSet<int> { 0, 1, 2 };
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(18));
        }
​
        [Test]
        public void NoPathTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5)
            };
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(-1));
        }
​
        [Test]
        public void SameSourceDestinationTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5)
            };
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 0;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(0));
        }
​
        [Test]
        public void LargeGraphTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>();
            for (int i = 0; i < 100; i++)
            {
                flightPaths.Add(Tuple.Create(i, i + 1, 1));
            }
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 100;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(100));
        }
​
        [Test]
        public void ZeroFlightTimesTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 0),
                Tuple.Create(1, 2, 0)
            };
            HashSet<int> processingCenters = new HashSet<int> { 1 };
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(3));
        }
​
        [Test]
        public void EmptyFlightPathsTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>();
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 2;
            int processingDelay = 3;
            Assert.That(DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay), Is.EqualTo(-1));
        }
​
        [Test]
        public void NegativeProcessingDelayTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5)
            };
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 1;
            int processingDelay = -3;
            Assert.Throws<ArgumentException>(() => DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay));
        }
​
        [Test]
        public void NullFlightPathsTest()
        {
            List<Tuple<int, int, int>> flightPaths = null;
            HashSet<int> processingCenters = new HashSet<int>();
            int source = 0;
            int destination = 1;
            int processingDelay = 3;
            Assert.Throws<ArgumentNullException>(() => DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay));
        }
​
        [Test]
        public void NullProcessingCentersTest()
        {
            List<Tuple<int, int, int>> flightPaths = new List<Tuple<int, int, int>>
            {
                Tuple.Create(0, 1, 5)
            };
            HashSet<int> processingCenters = null;
            int source = 0;
            int destination = 1;
            int processingDelay = 3;
            Assert.Throws<ArgumentNullException>(() => DroneDelivery.FindMinimumDeliveryTime(flightPaths, processingCenters, source, destination, processingDelay));
        }
    }
​
    public class PriorityQueue<T, TPriority> where TPriority : IComparable<TPriority>
    {
        private List<(T item, TPriority priority)> _elements = new List<(T item, TPriority priority)>();
​
        public int Count => _elements.Count;
​
        public void Enqueue(T item, TPriority priority)
        {
            _elements.Add((item, priority));
            _elements.Sort((x, y) => x.priority.CompareTo(y.priority));
        }
​
        public T Dequeue()
        {
            if (_elements.Count == 0)
            {
                throw new InvalidOperationException("Priority queue is empty.");
            }
            T item = _elements[0].item;
            _elements.RemoveAt(0);
            return item;
        }
    }
​
    public static void Main(string[] args)
    {
        // Instantiate the test fixture
        var tests = new DroneDeliveryTests();
        int passed = 0, failed = 0;
​
        // List of test methods to run
        var testMethods = new List<Action>
        {
            tests.BasicTest,
            tests.NoProcessingCentersTest,
            tests.AllHubsProcessingCentersTest,
            tests.NoPathTest,
            tests.SameSourceDestinationTest,
            tests.LargeGraphTest,
            tests.ZeroFlightTimesTest,
            tests.EmptyFlightPathsTest,
            tests.NegativeProcessingDelayTest,
            tests.NullFlightPathsTest,
            tests.NullProcessingCentersTest
        };
​
        // Execute each test and print the result.
        foreach (var test in testMethods)
        {
            try
            {
                test();
                Console.WriteLine($"{test.Method.Name}: Passed");
                passed++;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"{test.Method.Name}: Failed - {ex.Message}");
                failed++;
            }
        }
​
        Console.WriteLine($"Total tests: {passed + failed}, Passed: {passed}, Failed: {failed}");
    }
}
​

1x3a2b2c2a

Last Run:	1:07:15 pm
Compile:	0.079s
Execute:	0.06s
Memory:	2.89Mb
CPU:	0.139s

View IL Code