added dashboard server and built an example implementation for the message protocol

main/src/test/java/sd/dashboard/DashboardTest.java

@@ -0,0 +1,164 @@
+package sd.dashboard;
+
+import org.junit.jupiter.api.AfterEach;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import sd.config.SimulationConfig;
+import sd.model.VehicleType;
+
+/**
+ * Unit tests for Dashboard Server components.
+ */
+class DashboardTest {
+    
+    private DashboardStatistics statistics;
+    
+    @BeforeEach
+    void setUp() {
+        statistics = new DashboardStatistics();
+    }
+    
+    @AfterEach
+    void tearDown() {
+        statistics = null;
+    }
+    
+    @Test
+    void testInitialStatistics() {
+        assertEquals(0, statistics.getTotalVehiclesGenerated(), 
+            "Initial vehicles generated should be 0");
+        assertEquals(0, statistics.getTotalVehiclesCompleted(), 
+            "Initial vehicles completed should be 0");
+        assertEquals(0.0, statistics.getAverageSystemTime(), 
+            "Initial average system time should be 0.0");
+        assertEquals(0.0, statistics.getAverageWaitingTime(), 
+            "Initial average waiting time should be 0.0");
+    }
+    
+    @Test
+    void testVehicleCounters() {
+        statistics.incrementVehiclesGenerated();
+        assertEquals(1, statistics.getTotalVehiclesGenerated());
+        
+        statistics.updateVehiclesGenerated(10);
+        assertEquals(10, statistics.getTotalVehiclesGenerated());
+        
+        statistics.incrementVehiclesCompleted();
+        assertEquals(1, statistics.getTotalVehiclesCompleted());
+    }
+    
+    @Test
+    void testAverageCalculations() {
+        // Add 3 completed vehicles with known times
+        statistics.updateVehiclesCompleted(3);
+        statistics.addSystemTime(3000); // 3000ms total
+        statistics.addWaitingTime(1500); // 1500ms total
+        
+        assertEquals(1000.0, statistics.getAverageSystemTime(), 0.01,
+            "Average system time should be 1000ms");
+        assertEquals(500.0, statistics.getAverageWaitingTime(), 0.01,
+            "Average waiting time should be 500ms");
+    }
+    
+    @Test
+    void testVehicleTypeStatistics() {
+        statistics.incrementVehicleType(VehicleType.LIGHT);
+        statistics.incrementVehicleType(VehicleType.LIGHT);
+        statistics.incrementVehicleType(VehicleType.HEAVY);
+        
+        assertEquals(2, statistics.getVehicleTypeCount(VehicleType.LIGHT));
+        assertEquals(1, statistics.getVehicleTypeCount(VehicleType.HEAVY));
+        assertEquals(0, statistics.getVehicleTypeCount(VehicleType.BIKE));
+    }
+    
+    @Test
+    void testIntersectionStatistics() {
+        statistics.updateIntersectionStats("Cr1", 10, 8, 2);
+        
+        DashboardStatistics.IntersectionStats stats = 
+            statistics.getIntersectionStats("Cr1");
+        
+        assertNotNull(stats, "Intersection stats should not be null");
+        assertEquals("Cr1", stats.getIntersectionId());
+        assertEquals(10, stats.getTotalArrivals());
+        assertEquals(8, stats.getTotalDepartures());
+        assertEquals(2, stats.getCurrentQueueSize());
+    }
+    
+    @Test
+    void testMultipleIntersections() {
+        statistics.updateIntersectionStats("Cr1", 10, 8, 2);
+        statistics.updateIntersectionStats("Cr2", 15, 12, 3);
+        statistics.updateIntersectionStats("Cr3", 5, 5, 0);
+        
+        assertEquals(3, statistics.getAllIntersectionStats().size(),
+            "Should have 3 intersections");
+    }
+    
+    @Test
+    void testStatsUpdatePayload() {
+        StatsUpdatePayload payload = new StatsUpdatePayload()
+            .setTotalVehiclesGenerated(50)
+            .setTotalVehiclesCompleted(20)
+            .setIntersectionArrivals(30)
+            .setIntersectionDepartures(25)
+            .setIntersectionQueueSize(5);
+        
+        assertEquals(50, payload.getTotalVehiclesGenerated());
+        assertEquals(20, payload.getTotalVehiclesCompleted());
+        assertEquals(30, payload.getIntersectionArrivals());
+        assertEquals(25, payload.getIntersectionDepartures());
+        assertEquals(5, payload.getIntersectionQueueSize());
+    }
+    
+    @Test
+    void testStatsMessage() {
+        StatsUpdatePayload payload = new StatsUpdatePayload()
+            .setIntersectionArrivals(10);
+        
+        StatsMessage message = new StatsMessage("Cr1", payload);
+        
+        assertEquals("Cr1", message.getSourceNode());
+        assertEquals("DashboardServer", message.getDestinationNode());
+        assertEquals(sd.model.MessageType.STATS_UPDATE, message.getType());
+        assertNotNull(message.getPayload());
+    }
+    
+    @Test
+    void testThreadSafety() throws InterruptedException {
+        // Test concurrent updates
+        Thread t1 = new Thread(() -> {
+            for (int i = 0; i < 100; i++) {
+                statistics.incrementVehiclesGenerated();
+            }
+        });
+        
+        Thread t2 = new Thread(() -> {
+            for (int i = 0; i < 100; i++) {
+                statistics.incrementVehiclesGenerated();
+            }
+        });
+        
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        
+        assertEquals(200, statistics.getTotalVehiclesGenerated(),
+            "Concurrent increments should total 200");
+    }
+    
+    @Test
+    void testDashboardServerCreation() throws Exception {
+        SimulationConfig config = new SimulationConfig("simulation.properties");
+        DashboardServer server = new DashboardServer(config);
+        
+        assertNotNull(server, "Server should be created successfully");
+        assertNotNull(server.getStatistics(), "Statistics should be initialized");
+        assertFalse(server.isRunning(), "Server should not be running initially");
+    }
+}