Fixed test coverage issues and reorganized files to adhere to the Single Responsibility Principle.

Author: Wessam100

FiniteStateMachine/pom.xml

@@ -11,35 +11,17 @@
 
     <artifactId>FiniteStateMachine</artifactId>
 
-
     <properties>
         <maven.compiler.source>17</maven.compiler.source>
         <maven.compiler.target>17</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
     <dependencies>
         <dependency>
-            <groupId>org.mockito</groupId>
-            <artifactId>mockito-core</artifactId>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
         </dependency>
     </dependencies>
 
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.jacoco</groupId>
-                <artifactId>jacoco-maven-plugin</artifactId>
-                <version>0.8.7</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>prepare-agent</goal>
-                            <goal>report</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-
 </project>

FiniteStateMachine/src/main/java/com/iluwatar/TrafficLightFsm.java

@@ -0,0 +1,14 @@
+package trafficlight;
+
+
+/**
+ * Concrete state representing the Green Light.
+ */
+public class GreenLightState implements TrafficLightState {
+  @Override
+  public void handleEvent(TrafficLightContext context) {
+    System.out.println("Green Light: Go!");
+    context.setState(new YellowLightState());
+  }
+}
+

FiniteStateMachine/src/main/java/trafficlight/GreenLightState.java

@@ -0,0 +1,12 @@
+package trafficlight;
+/**
+ * Concrete state representing the Red Light.
+ */
+public class RedLightState implements TrafficLightState {
+  @Override
+  public void handleEvent(TrafficLightContext context) {
+    System.out.println("Red Light: Stop!");
+    context.setState(new GreenLightState());
+  }
+}
+

FiniteStateMachine/src/main/java/trafficlight/RedLightState.java

@@ -0,0 +1,42 @@
+package trafficlight;
+
+/**
+ * Context class for managing the current state and transitions.
+ */
+public class TrafficLightContext {
+  private TrafficLightState currentState;
+
+  /**
+   * Initializes the context with the given initial state.
+   *
+   * @param initialState the initial state of the traffic light
+   */
+  public TrafficLightContext(TrafficLightState initialState) {
+    this.currentState = initialState;
+  }
+
+  /**
+   * Updates the current state of the traffic light.
+   *
+   * @param newState the new state to transition to
+   */
+  public void setState(TrafficLightState newState) {
+    this.currentState = newState;
+  }
+
+  /**
+   * Handles the current state's event and transitions to the next state.
+   */
+  public void handleEvent() {
+    currentState.handleEvent(this);
+  }
+
+  /**
+   * Gets the current state of the traffic light.
+   * This can be useful for testing purposes.
+   */
+  public TrafficLightState getCurrentState() {
+    return currentState;
+  }
+}
+

FiniteStateMachine/src/main/java/trafficlight/TrafficLightContext.java

@@ -0,0 +1,29 @@
+/**
+ * Package for simulating a traffic light system using states.
+ */
+package trafficlight;
+
+/**
+ * Simulates a traffic light system using a Finite State Machine (FSM).
+ */
+public class TrafficLightFsm {
+
+  /**
+   * Runs the traffic light simulation.
+   *
+   * @param args command-line arguments (not used here)
+   */
+  public static void main(String[] args) {
+    // Start with the Red light
+    TrafficLightContext trafficLight = new TrafficLightContext(new RedLightState());
+
+    // Cycle through the traffic light states
+    for (int i = 0; i < 6; i++) {
+      trafficLight.handleEvent();
+    }
+  }
+}
+
+
+
+

FiniteStateMachine/src/main/java/trafficlight/TrafficLightFsm.java

@@ -0,0 +1,18 @@
+package trafficlight;
+
+/**
+ * State interface for traffic light states.
+ */
+public interface TrafficLightState {
+
+  /**
+   * Handles the transition to the next state based on the current state.
+   *
+   * @param context the context object that manages the traffic light's state
+   */
+  void handleEvent(TrafficLightContext context);
+}
+
+
+
+

FiniteStateMachine/src/main/java/trafficlight/TrafficLightState.java

@@ -0,0 +1,12 @@
+package trafficlight;
+
+/**
+ * Concrete state representing the Yellow Light.
+ */
+public class YellowLightState implements TrafficLightState {
+  @Override
+  public void handleEvent(TrafficLightContext context) {
+    System.out.println("Yellow Light: Caution!");
+    context.setState(new RedLightState());
+  }
+}

FiniteStateMachine/src/main/java/trafficlight/YellowLightState.java

@@ -0,0 +1,57 @@
+package trafficlight;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for the Traffic Light FSM.
+ */
+public class TrafficLightTest {
+
+  private TrafficLightContext context;
+
+  @BeforeEach
+  void setUp() {
+    // Start with the Red Light state
+    context = new TrafficLightContext(new RedLightState());
+  }
+
+  @Test
+  void testInitialState() {
+    assertTrue(context.getCurrentState() instanceof RedLightState, "Initial state should be RedLightState.");
+  }
+
+  @Test
+  void testRedToGreenTransition() {
+    context.handleEvent();
+    assertTrue(context.getCurrentState() instanceof GreenLightState, "Red Light should transition to Green Light.");
+  }
+
+  @Test
+  void testGreenToYellowTransition() {
+    context.setState(new GreenLightState());
+    context.handleEvent();
+    assertTrue(context.getCurrentState() instanceof YellowLightState, "Green Light should transition to Yellow Light.");
+  }
+
+  @Test
+  void testYellowToRedTransition() {
+    context.setState(new YellowLightState());
+    context.handleEvent();
+    assertTrue(context.getCurrentState() instanceof RedLightState, "Yellow Light should transition to Red Light.");
+  }
+
+  @Test
+  void testFullCycle() {
+    context.handleEvent(); // Red -> Green
+    assertTrue(context.getCurrentState() instanceof GreenLightState);
+
+    context.handleEvent(); // Green -> Yellow
+    assertTrue(context.getCurrentState() instanceof YellowLightState);
+
+    context.handleEvent(); // Yellow -> Red
+    assertTrue(context.getCurrentState() instanceof RedLightState);
+  }
+}