ci/test: add automated simulation testing to CI/CD and unit test suite

build.gradle

@@ -99,11 +99,16 @@ dependencies {
 test {
     useJUnitPlatform()
     systemProperty 'junit.jupiter.extensions.autodetection.enabled', 'true'
+    testLogging {
+        events "passed", "skipped", "failed"
+        exceptionFormat "full"
+    }
 }
 
 // Simulation configuration (e.g. environment variables).
-wpi.sim.addGui().defaultEnabled = true
-wpi.sim.addDriverstation()
+def isCI = System.getenv("CI") != null || project.hasProperty("headless")
+wpi.sim.addGui().defaultEnabled = !isCI
+wpi.sim.addDriverstation().defaultEnabled = !isCI
 
 // Setting up my Jar File. In this case, adding all libraries into the main jar ('fat jar')
 // in order to make them all available at runtime. Also adding the manifest so WPILib

docs/tools/simulation.md

@@ -47,6 +47,25 @@ That view is especially useful for autos. Select the auto in Elastic or Glass, e
 
 AdvantageScope can also replay the same data from a `.wpilog` after the run. That makes the workflow: test the auto in sim, use 3D Field live while it runs, then open the saved log if you need to scrub frame-by-frame through the exact moment the path or pose estimate went sideways.
 
+## Automated Simulation Testing in CI/CD
+
+In addition to interactive debugging in Glass and AdvantageScope, the repository runs automated JUnit 5 simulation integration tests as part of `./gradlew build` and GitHub Actions CI.
+
+The simulation test suite lives under [`src/test/java/frc/robot/sim/`](../../src/test/java/frc/robot/sim/) and is built around [`SimTestBase`](../../src/test/java/frc/robot/sim/SimTestBase.java), which handles:
+
+* Initializing WPILib's Hardware Abstraction Layer (HAL) in simulation mode (`HAL.initialize(50, 0)`).
+* Managing `DriverStationSim` state transitions (teleop and autonomous modes).
+* Stepping simulation timing deterministically via `SimHooks.stepTiming(...)` and executing the `CommandScheduler`.
+* Resetting scheduler, notifier, and DriverStation state between test runs so tests remain isolated.
+
+In CI (`CI=true`) or when `-Pheadless=true` is passed to Gradle, `wpi.sim.addGui().defaultEnabled` and `wpi.sim.addDriverstation().defaultEnabled` are automatically set to `false`, allowing simulation tests to run in headless Ubuntu Linux containers without requiring X11 display servers.
+
+You can run the full verification suite locally using:
+
+```bash
+scripts/verify.sh
+```
+
 ## What Simulation Catches (and Doesn't)
 
 It catches:

scripts/verify.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -e
+
+# Change to repo root
+cd "$(dirname "$0")/.."
+
+if [ "$1" = "--fix" ]; then
+    echo "=== Running Spotless Apply ==="
+    ./gradlew spotlessApply
+else
+    echo "=== Running Spotless Check ==="
+    ./gradlew spotlessCheck
+fi
+
+echo "=== Running SpotBugs Static Analysis ==="
+./gradlew spotbugsMain
+
+echo "=== Running Compile and Tests (Unit & Sim Tests) ==="
+./gradlew test -Pheadless=true
+
+echo "=== Verification SUCCESSFUL ==="

src/main/java/frc/robot/auton/Auton.java

@@ -22,6 +22,7 @@
 import frc.spectrumLib.framework.SpectrumState;
 import frc.spectrumLib.telemetry.Telemetry;
 import java.io.IOException;
+import lombok.Getter;
 import org.json.simple.parser.ParseException;
 
 public class Auton {
@@ -35,7 +36,7 @@ public class Auton {
     public static final EventTrigger autonUnjam = new EventTrigger("unjam");
     public static final EventTrigger autonPoseUpdate = new EventTrigger("poseUpdate");
 
-    private final SendableChooser<Command> pathChooser = new SendableChooser<>();
+    @Getter private final SendableChooser<Command> pathChooser = new SendableChooser<>();
     private boolean autoMessagePrinted = true;
     private double autonStart = 0;
 

src/main/java/frc/robot/subsystems/swerve/Swerve.java

@@ -56,7 +56,8 @@
  * Class that extends the Phoenix SwerveDrivetrain class and implements subsystem so it can be used
  * in command-based projects easily.
  */
-public class Swerve extends SwerveDrivetrain<TalonFX, TalonFX, CANcoder> implements Subsystem {
+public class Swerve extends SwerveDrivetrain<TalonFX, TalonFX, CANcoder>
+        implements Subsystem, AutoCloseable {
 
     // ── State machine ──────────────────────────────────────────────────────────────────
     public enum WantedState {
@@ -747,7 +748,10 @@ private void configurePathPlanner() {
     @Getter private RobotBumpSim robotBumpSim = null;
     @Getter private Pose3d simRobotPose3d = Pose3d.kZero;
 
-    /** Starts the sim thread. */
+    /**
+     * Starts the simulated drivetrain and bump simulation, then schedules periodic simulation
+     * updates.
+     */
     @SuppressWarnings("unchecked")
     private void startSimThread() {
         mapleSimSwerveDrivetrain =
@@ -772,4 +776,13 @@ private void startSimThread() {
         simNotifier = new Notifier(mapleSimSwerveDrivetrain::update);
         simNotifier.startPeriodic(config.getSimLoopPeriod());
     }
+
+    /** Stops the simulation thread and cleans up resources. */
+    @Override
+    public void close() {
+        if (simNotifier != null) {
+            simNotifier.close();
+            simNotifier = null;
+        }
+    }
 }

src/main/java/frc/spectrumLib/sim/SimLoop.java

@@ -42,7 +42,11 @@ public static synchronized void register(DoubleConsumer step) {
             notifier = started;
         }
     }
-    /** Tick. */
+    /**
+     * Advances the simulation loop and notifies each registered callback of the elapsed time.
+     *
+     * @param dt the elapsed time in seconds since the previous update
+     */
     private static void tick() {
         double now = Utils.getCurrentTimeSeconds();
         double dt = now - lastTime;
@@ -51,4 +55,16 @@ private static void tick() {
             step.accept(dt);
         }
     }
+
+    /**
+     * Clears registered step callbacks and stops the notifier thread. Intended for unit/simulation
+     * tests.
+     */
+    public static synchronized void reset() {
+        steps.clear();
+        if (notifier != null) {
+            notifier.close();
+            notifier = null;
+        }
+    }
 }

src/test/java/frc/robot/sim/AutonSimTest.java

@@ -0,0 +1,46 @@
+package frc.robot.sim;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import edu.wpi.first.wpilibj2.command.CommandScheduler;
+import frc.robot.auton.Auton;
+import frc.robot.subsystems.swerve.Swerve;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+/** Automated simulation tests for the autonomous routine chooser and execution. */
+public class AutonSimTest extends SimTestBase {
+
+    @Test
+    @DisplayName("Auton initializes the SendableChooser and default option without exceptions")
+    void testAutonChooserInitialization() {
+        assertDoesNotThrow(
+                () -> {
+                    RobotStack stack = createRobotStack();
+                    try (Swerve swerve = stack.swerve) {
+                        Auton auton = new Auton(stack.superStructure);
+                        assertNotNull(auton.getPathChooser());
+                        assertNotNull(auton.getPathChooser().getSelected());
+                    }
+                });
+    }
+
+    @Test
+    @DisplayName("Auton init schedules the selected auto and steps simulation time cleanly")
+    void testAutonInitAndStep() {
+        assertDoesNotThrow(
+                () -> {
+                    RobotStack stack = createRobotStack();
+                    try (Swerve swerve = stack.swerve) {
+                        Auton auton = new Auton(stack.superStructure);
+                        CommandScheduler.getInstance().registerSubsystem(stack.superStructure);
+
+                        enableAutonomousSim();
+                        auton.init();
+
+                        stepSim(0.020, 0.50);
+                    }
+                });
+    }
+}

src/test/java/frc/robot/sim/MechanismSimTest.java

@@ -0,0 +1,68 @@
+package frc.robot.sim;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import edu.wpi.first.wpilibj2.command.CommandScheduler;
+import frc.robot.subsystems.hood.Hood;
+import frc.robot.subsystems.intakeExtension.IntakeExtension;
+import frc.robot.subsystems.turret.Turret;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+/** Automated simulation tests for individual mechanism subsystems. */
+public class MechanismSimTest extends SimTestBase {
+
+    @Test
+    @DisplayName("Hood subsystem initializes and runs simulation steps without exceptions")
+    void testHoodSimPeriodic() {
+        assertDoesNotThrow(
+                () -> {
+                    Hood hood = new Hood(new Hood.HoodConfig());
+                    CommandScheduler.getInstance().registerSubsystem(hood);
+
+                    enableTeleopSim();
+                    stepSim(0.020, 0.50);
+
+                    assertNotNull(hood.getSim());
+                });
+    }
+
+    @Test
+    @DisplayName("Turret subsystem initializes and runs simulation steps without exceptions")
+    void testTurretSimPeriodic() {
+        assertDoesNotThrow(
+                () -> {
+                    Turret turret = new Turret(new Turret.TurretConfig());
+                    CommandScheduler.getInstance().registerSubsystem(turret);
+
+                    enableTeleopSim();
+                    stepSim(0.020, 0.50);
+
+                    assertNotNull(turret.getSim());
+                });
+    }
+
+    @Test
+    @DisplayName(
+            "IntakeExtension subsystem initializes and runs simulation steps without exceptions")
+    void testIntakeExtensionSimPeriodic() {
+        assertDoesNotThrow(
+                () -> {
+                    IntakeExtension.Left.LeftConfig leftConfig =
+                            new IntakeExtension.Left.LeftConfig();
+                    IntakeExtension.Right.RightConfig rightConfig =
+                            new IntakeExtension.Right.RightConfig(leftConfig);
+                    IntakeExtension intakeExtension =
+                            new IntakeExtension(
+                                    new IntakeExtension.IntakeExtensionConfig(
+                                            leftConfig, rightConfig));
+                    CommandScheduler.getInstance().registerSubsystem(intakeExtension);
+
+                    enableTeleopSim();
+                    stepSim(0.020, 0.50);
+
+                    assertNotNull(intakeExtension.getSim());
+                });
+    }
+}

src/test/java/frc/robot/sim/RobotSimTest.java

@@ -0,0 +1,37 @@
+package frc.robot.sim;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import edu.wpi.first.wpilibj2.command.CommandScheduler;
+import frc.robot.RobotSim;
+import frc.robot.subsystems.swerve.Swerve;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+/** Automated simulation tests for the RobotSim visualizer and fuel physics simulation. */
+public class RobotSimTest extends SimTestBase {
+
+    @Test
+    @DisplayName("RobotSim initializes visualizer and fuel physics and updates cleanly")
+    void testRobotSimCreationAndPeriodic() {
+        assertDoesNotThrow(
+                () -> {
+                    RobotStack stack = createRobotStack();
+                    try (Swerve swerve = stack.swerve) {
+                        RobotSim robotSim = new RobotSim(stack.superStructure);
+                        CommandScheduler.getInstance().registerSubsystem(stack.superStructure);
+
+                        assertNotNull(robotSim.getBallSim());
+                        assertNotNull(RobotSim.leftView);
+                        assertNotNull(RobotSim.topView);
+
+                        enableTeleopSim();
+                        stepSim(0.020, 0.50);
+
+                        robotSim.updateArticulatedMechanisms();
+                        robotSim.getBallSim().tick();
+                    }
+                });
+    }
+}