🚀 3단계 - 자동차 경주 (#5971)

* [step2] 2단계 - 문자열 덧셈 계산기 구현

* [step3] 사용자 입력 처리 기능 구현

* [step3] 자동차 이동로직 구현

* [step3] 자동차 상태 출력 구현

* [step3] refactor : racingCar 구조 개선
- Car 도메인 객체 추가
- 입력값에대한 검증 추가
- 매직넘버, Random 객체 상수화
- 테스트 코드 수정

* [step3] refactor : racingCar 구조 개선
- 기존 RacingCar  -> RacingCarService 변경
- 일급컬렉션 RacingCar 추가
- MovingStrategy interface 추가
- RandomGenerator, RandomStrategy 추가
- 테스트 코드 수정

* [step3] refactor : racingCar 구조 개선
- RacingCarService -> RacingCar 원복
- 일급컬렉션 Cars 추가
- Race class 추가
- 테스트 코드 수정

* fix : main 함수 제거 및 CAR 상수값 변경

Author: jiyoung928

src/main/java/racingcar/RacingCar.java

@@ -0,0 +1,33 @@
+package racingcar;
+
+import racingcar.domain.Car;
+import racingcar.domain.Cars;
+import racingcar.domain.Race;
+import racingcar.generator.RandomGenerator;
+import racingcar.strategy.RandomStrategy;
+import racingcar.ui.InputView;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RacingCar {
+
+    public static void gameStart() {
+        Cars cars = new Cars(getCars(InputView.inputValidatedNumberOfCar()));
+        Race race = new Race(cars, InputView.inputValidatedNumberOfAttempts());
+        race.start(createRandomStrategy());
+    }
+
+    public static ArrayList<Car> getCars(int car) {
+        ArrayList<Car> cars = new ArrayList<>();
+        for(int i=0; i<car; i++){
+            cars.add(new Car());
+        }
+        return cars;
+    }
+
+    private static RandomStrategy createRandomStrategy() {
+        return new RandomStrategy(new RandomGenerator());
+    }
+
+}

src/main/java/racingcar/domain/Car.java

@@ -0,0 +1,23 @@
+package racingcar.domain;
+
+import racingcar.strategy.MovingStrategy;
+
+public class Car {
+    private int moveCount;
+
+    public Car() {
+        this.moveCount = 1;
+    }
+
+    public int getMoveCount() {
+        return moveCount;
+    }
+
+
+    public void move(MovingStrategy movingStrategy) {
+        if(movingStrategy.isMove()){
+            moveCount++;
+        }
+    }
+
+}

src/main/java/racingcar/domain/Cars.java

@@ -0,0 +1,25 @@
+package racingcar.domain;
+
+import racingcar.strategy.MovingStrategy;
+import racingcar.ui.ResultView;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Cars {
+
+    private final List<Car> cars;
+
+    public Cars(List<Car> cars) {
+        this.cars = new ArrayList<>(cars);
+    }
+
+    public void moveAll(MovingStrategy strategy) {
+        cars.forEach(car -> car.move(strategy));
+    }
+
+    public List<Car> getCurrentStatus() {
+        return Collections.unmodifiableList(cars);
+    }
+}

src/main/java/racingcar/domain/Race.java

@@ -0,0 +1,23 @@
+package racingcar.domain;
+
+import racingcar.strategy.MovingStrategy;
+import racingcar.ui.ResultView;
+
+public class Race {
+    private final Cars cars;
+    private final int totalAttempts;
+
+    public Race(Cars cars, int totalAttempts) {
+        this.cars = cars;
+        this.totalAttempts = totalAttempts;
+    }
+
+    public void start(MovingStrategy strategy) {
+        System.out.println("실행 결과");
+        ResultView.viewRacingCar(cars.getCurrentStatus());
+        for (int attempt = 1; attempt < totalAttempts; attempt++) {
+            cars.moveAll(strategy);
+            ResultView.viewRacingCar(cars.getCurrentStatus());
+        }
+    }
+}

src/main/java/racingcar/generator/RandomGenerator.java

@@ -0,0 +1,12 @@
+package racingcar.generator;
+
+import java.util.Random;
+
+public class RandomGenerator {
+    public static final Random RANDOM = new Random();
+    public static final int RANDOM_MAX_NUMBER = 10;
+
+    public static int generate() {
+        return RANDOM.nextInt(RANDOM_MAX_NUMBER);
+    }
+}

src/main/java/racingcar/strategy/MovingStrategy.java

@@ -0,0 +1,5 @@
+package racingcar.strategy;
+
+public interface MovingStrategy {
+    boolean isMove();
+}

src/main/java/racingcar/strategy/RandomStrategy.java

@@ -0,0 +1,20 @@
+package racingcar.strategy;
+
+import racingcar.generator.RandomGenerator;
+
+public class RandomStrategy implements MovingStrategy {
+
+    private static final int RANDOM_MIN_NUMBER = 4;
+    private final RandomGenerator randomGenerator;
+
+    public RandomStrategy(RandomGenerator randomGenerator) {
+        this.randomGenerator = randomGenerator;
+    }
+
+    @Override
+    public boolean isMove() {
+        return randomGenerator.generate() >= RANDOM_MIN_NUMBER;
+    }
+
+
+}

src/main/java/racingcar/ui/InputView.java

@@ -0,0 +1,43 @@
+package racingcar.ui;
+
+import java.util.Scanner;
+
+public class InputView {
+
+    public static Scanner SCANNER = new Scanner(System.in);
+    public static final int CAR_MIN = 0;
+    public static final int NUM_MIN = 0;
+
+    // 테스트를 위한 Scanner 설정 메소드
+    public static void setScanner(Scanner scanner) {
+        SCANNER = scanner;
+    }
+
+    public static int inputNumberOfCar() {
+        System.out.println("자동차 대수는 몇 대 인가요?");
+        return SCANNER.nextInt();
+    }
+    public static int inputNumberOfAttempts() {
+        System.out.println("시도할 회수는 몇 회 인가요?");
+        return SCANNER.nextInt();
+    }
+
+    public static int inputValidatedNumberOfCar() {
+        int input = inputNumberOfCar();
+        validateInput(input, "차량 수", CAR_MIN);
+        return input;
+    }
+    public static int inputValidatedNumberOfAttempts() {
+        int input = inputNumberOfAttempts();
+        validateInput(input, "시도 횟수", NUM_MIN);
+        return input;
+    }
+
+    private static void validateInput(int value, String fieldName, int min) {
+        if (value <= min) {
+            throw new IllegalArgumentException(
+                    String.format("[ERROR] %s는 %d보다 값이어야 합니다.", fieldName, min)
+            );
+        }
+    }
+}

src/main/java/racingcar/ui/ResultView.java

@@ -0,0 +1,19 @@
+package racingcar.ui;
+
+import racingcar.domain.Car;
+
+import java.util.List;
+
+public class ResultView {
+
+    public static void viewRacingCar(List<Car> cars) {
+        for(Car car : cars) {
+            for(int i = 0; i < car.getMoveCount(); i++){
+                System.out.print("-");
+            }
+            System.out.println();
+        }
+        System.out.println();
+
+    }
+}

src/test/java/racingcar/RacingCarTest.java

@@ -0,0 +1,103 @@
+package racingcar;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import racingcar.domain.Car;
+import racingcar.domain.Cars;
+import racingcar.generator.RandomGenerator;
+import racingcar.ui.InputView;
+
+import java.io.ByteArrayInputStream;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+public class RacingCarTest {
+
+    private static final int CAR = 3;
+    Car car;
+    Cars cars;
+
+    @BeforeEach
+    void setUp() {
+        car = new Car(); // 1로 초기화
+        cars = new Cars(RacingCar.getCars(CAR));
+    }
+
+    @Test
+    @DisplayName("전진 조건에 만족하면 전진")
+    void move(){
+        car.move(()->true);
+        assertThat(car.getMoveCount()).isEqualTo(2);
+    }
+
+    @Test
+    @DisplayName("전진 조건에 만족하지 않으면 멈춤")
+    void stop(){
+        car.move(()->false);
+        assertThat(car.getMoveCount()).isEqualTo(1);
+    }
+
+    @Test
+    @DisplayName("전진 조건에 만족하면 모두 전진")
+    void moveAll(){
+        cars.moveAll(()->true);
+
+        assertAll(
+                () -> assertThat(cars.getCurrentStatus().get(0).getMoveCount()).isEqualTo(2),
+                () -> assertThat(cars.getCurrentStatus().get(1).getMoveCount()).isEqualTo(2),
+                () -> assertThat(cars.getCurrentStatus().get(2).getMoveCount()).isEqualTo(2)
+                );
+    }
+
+    @Test
+    @DisplayName("전진 조건에 만족하지 않으면 모두 멈춤")
+    void stopAll(){
+        cars.moveAll(()->false);
+
+        assertAll(
+                () -> assertThat(cars.getCurrentStatus().get(0).getMoveCount()).isEqualTo(1),
+                () -> assertThat(cars.getCurrentStatus().get(1).getMoveCount()).isEqualTo(1),
+                () -> assertThat(cars.getCurrentStatus().get(2).getMoveCount()).isEqualTo(1)
+        );
+    }
+
+    @Test
+    @DisplayName("random 값은 0과 9사이 값")
+    void random(){
+        assertThat(RandomGenerator.generate()).isBetween(0, 9);
+    }
+
+    @Test
+    @DisplayName("자동차 대수가 0보다 작을 경우 오류 리턴")
+    void inputCar(){
+        String input = "0";
+        InputView.setScanner(new Scanner(new ByteArrayInputStream(input.getBytes())));
+
+        assertThatThrownBy(InputView::inputValidatedNumberOfCar)
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    @DisplayName("시도할 회수가 0보다 작을 경우 오류 리턴")
+    void inputAttempts(){
+        String input = "0";
+        InputView.setScanner(new Scanner(new ByteArrayInputStream(input.getBytes())));
+
+        assertThatThrownBy(InputView::inputValidatedNumberOfAttempts)
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    @DisplayName("반환된 자동차 List의 크기는 입력된 크기와 같다.")
+    public void getCars() {
+        ArrayList<Car> cars = RacingCar.getCars(CAR);
+        assertThat(cars.size()).isEqualTo(CAR);
+    }
+
+
+}

src/test/java/요구사항.md

@@ -0,0 +1,22 @@
+# 자동차 경주 게임
+## 기능 요구 사항
+- 주어진 횟수 동안 n대의 자동차는 전진 또는 멈출 수 있다.
+- 사용자는 몇 대의 자동차로 몇 번의 이동을 할 것인지를 입력할 수 있어야 한다.
+- 전진하는 조건은 0에서 9 사이에서 random 값을 구한 후 random 값이 4이상일 경우이다.
+- 자동차의 상태를 화면에 출력한다. 어느 시점에 출력할 것인지에 대한 제약은 없다.
+
+## 구현 계획
+
+- [x] 사용자 입력 처리 기능 구현
+- [x] 자동차 이동 로직 구현
+- [x] 자동차 상태 출력 기능 구현
+
+## 개발 환경
+
+- 언어: Java
+- IDE: IntelliJ IDEA 
+
+
+
+
+