[자동차 경주] 나성 미션 제출합니다.

src/main/java/Application.java

@@ -0,0 +1,14 @@
+import controller.RaceController;
+import view.RaceOutputView;
+
+import java.util.Random;
+
+public class Application {
+
+    public static void main(String[] args) {
+        Random random = new Random();
+        RaceOutputView raceOutputView = new RaceOutputView();
+        RaceController raceController = new RaceController(raceOutputView, random);
+        raceController.start();
+    }
+}

src/main/java/controller/RaceController.java

@@ -0,0 +1,34 @@
+package controller;
+
+import model.Car;
+import model.Racing;
+import model.dto.RacingPlayResponse;
+import view.RaceOutputView;
+import view.UserInputView;
+
+import java.util.Random;
+
+public class RaceController {
+
+    private final RaceOutputView raceOutputView;
+    private final Random random;
+
+    public RaceController(RaceOutputView raceOutputView, Random random) {
+        this.raceOutputView = raceOutputView;
+        this.random = random;
+    }
+
+    public void start() {
+        raceOutputView.inputCarNames();
+        String carNames = UserInputView.readStringInput();
+        raceOutputView.inputRaceCount();
+        int raceCount = UserInputView.readIntegerInput();
+
+        Racing racing = new Racing(random);
+        RacingPlayResponse response = racing.play(carNames, raceCount);
+
+        raceOutputView.printRacingData(response.moveData());
+        raceOutputView.printWinners(response.winners()
+                .stream().map(Car::getName).toList());
+    }
+}

src/main/java/model/Car.java

@@ -0,0 +1,41 @@
+package model;
+
+import java.util.Random;
+
+public class Car {
+
+    private final Random random;
+    private final String name;
+    private int position = 1;
+
+
+    public Car(String name, Random random) {
+        this.name = name;
+        validateCarName(name);
+        this.random = random;
+    }
+
+    private void validateCarName(String name) {
+        if(name == null || name.isBlank() || name.length() > 5) {
+            throw new IllegalArgumentException("5자 이하의 이름을 작성해주세요.");
+        }
+    }
+
+    public void move() {
+        if (canMove()) {
+            position++;
+        }
+    }
+
+    private boolean canMove() {
+        return random.nextInt(10) >= 4;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+}

src/main/java/model/Cars.java

@@ -0,0 +1,31 @@
+package model;
+
+import java.util.List;
+import java.util.Random;
+
+public class Cars {
+
+    private final List<Car> cars;
+
+    public Cars(Random random, List<String> carNames) {
+        this.cars = carNames.stream()
+                .map(carName -> new Car(carName, random))
+                .toList();
+
+    }
+
+    public void allMove(){
+        cars.forEach(Car::move);
+    }
+
+    public int findMaxDistance(){
+        return cars.stream()
+                .mapToInt(Car::getPosition)
+                .max()
+                .orElse(0);
+    }
+
+    public List<Car> getCars() {
+        return cars;
+    }
+}

src/main/java/model/Racing.java

@@ -0,0 +1,52 @@
+package model;
+
+import model.dto.RacingPlayResponse;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Racing {
+
+    private final Random rand;
+
+    public Racing(Random rand) {
+        this.rand = rand;
+    }
+
+    public RacingPlayResponse play(String inputCarNames, int raceCount) {
+        List<String> carNames = Arrays.stream(inputCarNames.split(",")).toList();
+        Cars cars = new Cars(rand, carNames);
+        List<Map<String, Integer>> moveData = runRacing(raceCount, cars);
+
+        return new RacingPlayResponse(moveData, getWinners(cars));
+    }
+
+    private List<Map<String, Integer>> runRacing(int raceCount, Cars cars) {
+        List<Map<String, Integer>> moveData = new ArrayList<>();
+        moveData.add(getSnapshot(cars));
+        IntStream.range(0, raceCount)
+                .forEach(i -> moveData.add(moveAndGetSnapshot(cars)));
+
+        return moveData;
+    }
+
+    private Map<String, Integer> moveAndGetSnapshot(Cars cars) {
+        cars.allMove();
+
+        return getSnapshot(cars);
+    }
+
+    private Map<String, Integer> getSnapshot(Cars cars) {
+        return cars.getCars().stream()
+                .collect(Collectors.toMap(Car::getName, Car::getPosition));
+    }
+
+    private List<Car> getWinners(Cars cars) {
+        int maxDistance = cars.findMaxDistance();
+
+        return cars.getCars().stream()
+                .filter(car -> car.getPosition() == maxDistance)
+                .toList();
+    }
+}

src/main/java/model/dto/RacingPlayResponse.java

@@ -0,0 +1,12 @@
+package model.dto;
+
+import model.Car;
+
+import java.util.List;
+import java.util.Map;
+
+public record RacingPlayResponse(
+        List<Map<String, Integer>> moveData,
+        List<Car> winners
+) {
+}

src/main/java/view/RaceOutputView.java

@@ -0,0 +1,30 @@
+package view;
+
+import java.util.List;
+import java.util.Map;
+
+public class RaceOutputView {
+
+    public void inputCarNames() {
+        System.out.println("경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분).");
+    }
+
+    public void inputRaceCount() {
+        System.out.println("시도할 회수는 몇회인가요?");
+    }
+
+    public void printRacingData(List<Map<String, Integer>> moveData) {
+        System.out.println("\n실행 결과");
+        for (Map<String, Integer> data : moveData) {
+            data.forEach(
+                    (key, value) ->
+                            System.out.println(key + " : " + "-".repeat(value))
+            );
+            System.out.println();
+        }
+    }
+
+    public void printWinners(List<String> winnerNames) {
+        System.out.println(String.join(", ", winnerNames) + "가 최종 우승했습니다.");
+    }
+}

src/main/java/view/UserInputView.java

@@ -0,0 +1,16 @@
+package view;
+
+import java.util.Scanner;
+
+public class UserInputView {
+
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public static String readStringInput() {
+        return scanner.nextLine();
+    }
+
+    public static int readIntegerInput() {
+        return scanner.nextInt();
+    }
+}

src/test/java/common/FakeRandom.java

@@ -0,0 +1,23 @@
+package common;
+
+import java.util.List;
+import java.util.Random;
+
+public class FakeRandom extends Random {
+
+    private  int index;
+    private final List<Integer> fixedValues;
+
+    public FakeRandom(List<Integer> fixedValues) {
+        this.fixedValues = fixedValues;
+    }
+
+    @Override
+    public int nextInt(int dummyBound) {
+        if(index >= fixedValues.size()) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        return fixedValues.get(index++);
+    }
+}

src/test/java/controller/RaceControllerTest.java

@@ -0,0 +1,52 @@
+package controller;
+
+import common.FakeRandom;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import view.RaceOutputView;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+
+import static fixture.FakeNumber.winnersNumbers;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RaceControllerTest {
+
+    private final RaceOutputView outputView = new RaceOutputView();
+
+    @Test
+    @DisplayName("OK : 자동차 레이싱 플레이")
+    void testRace_winners() throws IOException {
+        RaceController raceController = new RaceController(outputView, new FakeRandom(winnersNumbers));
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(outputStream));
+        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream("neo,brie,brown\n5\n".getBytes());
+        System.setIn(byteArrayInputStream);
+
+        raceController.start();
+
+        String output = outputStream.toString();
+        assertThat(output).contains("경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분).");
+        assertThat(output).contains("시도할 회수는 몇회인가요?");
+        assertThat(output).contains("실행 결과");
+        assertThat(output).contains("neo : -");
+        assertThat(output).contains("neo : --");
+        assertThat(output).contains("neo : ---");
+        assertThat(output).contains("neo : ----");
+        assertThat(output).contains("neo : -----");
+        assertThat(output).contains("brie : -");
+        assertThat(output).contains("brie : --");
+        assertThat(output).contains("brie : ---");
+        assertThat(output).contains("brie : ----");
+        assertThat(output).contains("brown : -");
+        assertThat(output).contains("brown : --");
+        assertThat(output).contains("brown : ---");
+        assertThat(output).contains("brown : ----");
+        assertThat(output).contains("brown : -----");
+        assertThat(output).contains("neo, brown가 최종 우승했습니다.");
+        byteArrayInputStream.close();
+    }
+}

src/test/java/fixture/FakeNumber.java

@@ -0,0 +1,23 @@
+package fixture;
+
+import java.util.List;
+
+public class FakeNumber {
+
+    public static final int MOVE_NUMBER = 4;
+    public static final int STOP_NUMBER = 3;
+    public static final List<Integer> winnerNumbers = List.of(
+            MOVE_NUMBER, MOVE_NUMBER, STOP_NUMBER,
+            STOP_NUMBER, MOVE_NUMBER, STOP_NUMBER,
+            STOP_NUMBER, MOVE_NUMBER, STOP_NUMBER,
+            STOP_NUMBER, MOVE_NUMBER, STOP_NUMBER,
+            STOP_NUMBER, MOVE_NUMBER, STOP_NUMBER
+    );
+    public static final List<Integer> winnersNumbers = List.of(
+            MOVE_NUMBER, STOP_NUMBER, MOVE_NUMBER,
+            MOVE_NUMBER, MOVE_NUMBER, MOVE_NUMBER,
+            MOVE_NUMBER, MOVE_NUMBER, MOVE_NUMBER,
+            MOVE_NUMBER, MOVE_NUMBER, MOVE_NUMBER,
+            STOP_NUMBER, STOP_NUMBER, STOP_NUMBER
+    );
+}

src/test/java/model/CarTest.java

@@ -0,0 +1,50 @@
+package model;
+
+import common.FakeRandom;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.List;
+import java.util.Random;
+
+import static fixture.FakeNumber.MOVE_NUMBER;
+import static fixture.FakeNumber.STOP_NUMBER;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class CarTest {
+
+    @ParameterizedTest()
+    @DisplayName("OK : 랜덤값이 4 이상일 시 움직임")
+    @ValueSource(ints = {MOVE_NUMBER, 9})
+    void carMove(int fixedValue){
+        Car car = createCar(fixedValue);
+        car.move();
+
+        assertThat(car.getPosition()).isEqualTo(2);
+    }
+
+    @ParameterizedTest()
+    @DisplayName("OK : 랜덤값이 4 미만일 시 움직이지 않음")
+    @ValueSource(ints = {0, STOP_NUMBER})
+    void carNotMove(int fixedValue){
+        Car car = createCar(fixedValue);
+        car.move();
+
+        assertThat(car.getPosition()).isEqualTo(1);
+    }
+
+    @Test
+    @DisplayName("ERROR : 이름 형식이 잘못됨")
+    void InvalidNameCar(){
+        Assertions.assertThrows(IllegalArgumentException.class, () -> new Car("", new Random()));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> new Car(" ", new Random()));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> new Car("test12", new Random()));
+    }
+
+    private Car createCar(int fixedValue){
+        return new Car("test1", new FakeRandom(List.of(fixedValue)));
+    }
+}