TTDCOMPLETE

pom.xml

@@ -9,8 +9,8 @@
     <version>1.0-SNAPSHOT</version>
 
     <properties>
-        <maven.compiler.source>23</maven.compiler.source>
-        <maven.compiler.target>23</maven.compiler.target>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 

src/main/java/object/example/kennethedelin/Car.java

@@ -0,0 +1,107 @@
+package object.example.kennethedelin;
+
+public class Car {
+
+    private String make;
+
+    private String model;
+
+    private int year;
+
+    private int mileage;
+
+    private boolean isRunning;
+
+    public Car(String make, String model, int year, int mileage, boolean isRunning) {
+
+        setMake(make);
+
+        setModel(model);
+
+        setYear(year);
+
+        setMileage(mileage);
+
+        this.isRunning = isRunning;
+    }
+
+    public String getMake() {
+
+        return make;
+    }
+
+    public void setMake(String make) {
+
+        if (make == null || make.isBlank()) {
+
+            throw new IllegalArgumentException("Make cannot be blank");
+        }
+        this.make = make;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public void setModel(String model) {
+        if (model == null || model.isBlank()) {
+
+            throw new IllegalArgumentException("Model cannot be blank");
+
+        }
+        this.model = model;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        if (year < 1886 || year > 2035) {
+
+            throw new IllegalArgumentException("Year must be between 1886 and 2035");
+
+        }
+        this.year = year;
+    }
+
+    public int getMileage() {
+        return mileage;
+    }
+
+    public void setMileage(int mileage) {
+        if (mileage < 0) {
+
+            throw new IllegalArgumentException("Mileage cannot be negative");
+        }
+        this.mileage = mileage;
+    }
+
+    public boolean isRunning() {
+        return isRunning;
+    }
+
+    public void setRunning(boolean running) {
+        isRunning = running;
+    }
+
+    public void startCar() {
+        isRunning = true;
+    }
+
+    public void stopCar() {
+        isRunning = false;
+    }
+
+    public void drive(int miles) {
+        if (!isRunning) {
+
+            throw new IllegalArgumentException("Car must be running to drive");
+        }
+        if (miles <= 0) {
+
+            throw new IllegalArgumentException("Miles must be greater than zero");
+        }
+        mileage += miles;
+    }
+}

src/test/java/object/kennethedelin/CarTest.java

@@ -0,0 +1,172 @@
+package object.kennethedelin;
+
+import object.example.kennethedelin.Car;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class CarTest {
+
+    @Test
+    void constructorShouldSetAllFieldsCorrectly() {
+
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, false);
+
+        // Act / Assert
+        assertEquals("Honda", car.getMake());
+
+        assertEquals("Civic", car.getModel());
+
+        assertEquals(2020, car.getYear());
+
+        assertEquals(25000, car.getMileage());
+
+        assertFalse(car.isRunning());
+    }
+
+    @Test
+    void setMakeShouldUpdateMake() {
+
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, false);
+
+        // Act
+        car.setMake("Toyota");
+
+        // Assert
+        assertEquals("Toyota", car.getMake());
+    }
+
+    @Test
+    void setModelShouldUpdateModel() {
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, false);
+
+        // Act
+        car.setModel("Corolla");
+
+        // Assert
+        assertEquals("Corolla", car.getModel());
+    }
+
+    @Test
+    void setYearShouldUpdateYear() {
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, false);
+
+        // Act
+        car.setYear(2022);
+
+        // Assert
+        assertEquals(2022, car.getYear());
+    }
+
+    @Test
+    void setMileageShouldUpdateMileage() {
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, false);
+
+        // Act
+        car.setMileage(30000);
+
+        // Assert
+        assertEquals(30000, car.getMileage());
+    }
+
+    @Test
+    void setRunningShouldUpdateRunningStatus() {
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, false);
+
+        // Act
+        car.setRunning(true);
+
+        // Assert
+        assertTrue(car.isRunning());
+    }
+
+    @Test
+    void startCarShouldTurnCarOn() {
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, false);
+
+        // Act
+        car.startCar();
+
+        // Assert
+        assertTrue(car.isRunning());
+    }
+
+    @Test
+    void stopCarShouldTurnCarOff() {
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, true);
+
+        // Act
+        car.stopCar();
+
+        // Assert
+        assertFalse(car.isRunning());
+    }
+
+    @Test
+    void driveShouldIncreaseMileageWhenCarIsRunning() {
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, true);
+
+        // Act
+        car.drive(50);
+
+        // Assert
+        assertEquals(25050, car.getMileage());
+    }
+
+    @Test
+    void constructorShouldThrowWhenMakeIsBlank() {
+        // Arrange / Act / Assert
+        assertThrows(IllegalArgumentException.class, () -> {
+
+            new Car("", "Civic", 2020, 25000, false);
+        });
+    }
+
+    @Test
+    void setMileageShouldThrowWhenMileageIsNegative() {
+
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, false);
+
+        // Act / Assert
+        assertThrows(IllegalArgumentException.class, () -> {
+            car.setMileage(-1);
+
+        });
+    }
+
+    @Test
+    void driveShouldThrowWhenCarIsNotRunning() {
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, false);
+
+        // Act / Assert
+        assertThrows(IllegalArgumentException.class, () -> {
+
+            car.drive(10);
+        });
+    }
+
+    @Test
+    void driveShouldThrowWhenMilesAreZeroOrLess() {
+
+        // Arrange
+        Car car = new Car("Honda", "Civic", 2020, 25000, true);
+
+        // Act / Assert
+        assertThrows(IllegalArgumentException.class, () -> {
+
+            car.drive(0);
+        });
+    }
+}