diff --git a/README.md b/README.md
index d0286c859f..d7160a30af 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,47 @@
-# java-racingcar-precourse
+# 🚗 자동차 경주 🏁
+
+## 기능 명세서
+
+> 📝 기능 명세서는 프로그램 실행 흐름에 따라 작성한다.<br/>
+> ☑️ 기능 구현은 주요 기능부터 먼저 구현한다.<br/>
+> ⚠️ 경주는 경쟁 상대가 있어야 하므로 유효한 이름을 2개 이상 입력해야 게임을 진행할 수 있다.
+
+### 경주할 자동차들의 이름을 입력받는다.
+
+- [X] 자동차 이름 입력을 요청하는 메시지를 출력한다.
+- [X] 입력된 문자열을 쉼표(,)를 기준으로 구분해 이름을 추출한다.
+- [X] 잘못된 값을 입력할 경우 `IllegalArgumentException`을 던진다.
+    - [X] 이름을 2개 미만으로 입력할 경우
+    - [X] 입력된 이름이 1자 미만, 5자 초과일 경우
+    - [X] 이름이 중복일 경우
+
+### 전진 시도 횟수를 입력받는다.
+
+- [X] 시도 횟수 입력 안내 메시지를 출력한다.
+- [X] 입력된 문자열을 자연수로 변환한다.
+- [X] 잘못된 값을 입력할 경우 `IllegalArgumentException`을 던진다.
+    - [X] 0~9로 이루어진 문자열이 아닌 경우
+    - [X] 1 미만의 수를 입력한 경우
+
+### 자동차 경주를 진행한다.
+
+- [X] 실행 결과 문구를 출력한다.
+- [X] 사용자가 입력한 시도 횟수만큼 반복한다.
+    - [X] 모든 자동차가 전진을 1번 시도한다.
+        - [X] 0부터 9까지의 정수 중 무작위 값을 1개 뽑는다.
+        - [X] 무작위 값이 4 이상이면 전진한다.
+    - [X] 한 라운드 실행 결과를 출력한다.
+        - [X] 1줄에 자동차 1개씩 이름과 이동한 횟수를 출력한다.
+
+### 게임 종료 후 우승자를 찾는다.
+
+- [X] 자동차들의 이동 횟수 중 최대값을 찾는다.
+- [X] 이동 횟수의 최대값을 가진 자동차들의 이름을 리턴한다.
+
+### 우승자를 알려준다.
+
+- [X] 우승자 안내 문구를 출력한다.
+    - [X] 우승자의 이름을 출력한다.
+    - [X] 공동 우승자는 쉼표(,)를 이용하여 구분한다.
+
+### `IllegalArgumentException`이 발생하면 애플리케이션을 종료한다.
\ No newline at end of file
diff --git a/src/main/java/racingcar/Application.java b/src/main/java/racingcar/Application.java
index a17a52e724..ec50c9b9a6 100644
--- a/src/main/java/racingcar/Application.java
+++ b/src/main/java/racingcar/Application.java
@@ -1,7 +1,12 @@
 package racingcar;
 
+import camp.nextstep.edu.missionutils.Console;
+import racingcar.config.AppConfig;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        AppConfig appConfig = new AppConfig();
+        appConfig.run();
+        Console.close();
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/racingcar/View/InputValidator.java b/src/main/java/racingcar/View/InputValidator.java
new file mode 100644
index 0000000000..7e00f8269d
--- /dev/null
+++ b/src/main/java/racingcar/View/InputValidator.java
@@ -0,0 +1,12 @@
+package racingcar.View;
+
+import static racingcar.View.ViewConstants.TOTAL_ROUNDS_REGEX;
+import static racingcar.View.ViewConstants.CONTAINS_NON_DIGIT_ERROR_MESSAGE;
+
+public class InputValidator {
+    public void validateThatContainsOnlyDigits(String input) {
+        if (!input.matches(TOTAL_ROUNDS_REGEX)) {
+            throw new IllegalArgumentException(CONTAINS_NON_DIGIT_ERROR_MESSAGE);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/racingcar/View/InputView.java b/src/main/java/racingcar/View/InputView.java
new file mode 100644
index 0000000000..4bdc9a2412
--- /dev/null
+++ b/src/main/java/racingcar/View/InputView.java
@@ -0,0 +1,18 @@
+package racingcar.View;
+
+import static racingcar.View.ViewConstants.ENTER_CAR_NAMES_MESSAGE;
+import static racingcar.View.ViewConstants.ENTER_TOTAL_ROUNDS_MESSAGE;
+
+import camp.nextstep.edu.missionutils.Console;
+
+public class InputView {
+    public String requestCarNames() {
+        System.out.println(ENTER_CAR_NAMES_MESSAGE);
+        return Console.readLine();
+    }
+
+    public String requestTotalRounds() {
+        System.out.println(ENTER_TOTAL_ROUNDS_MESSAGE);
+        return Console.readLine();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/racingcar/View/OutputView.java b/src/main/java/racingcar/View/OutputView.java
new file mode 100644
index 0000000000..0cab5b69ca
--- /dev/null
+++ b/src/main/java/racingcar/View/OutputView.java
@@ -0,0 +1,23 @@
+package racingcar.View;
+
+import static racingcar.View.ViewConstants.NAME_DELIMITER;
+import static racingcar.View.ViewConstants.RACE_RESULT;
+import static racingcar.View.ViewConstants.WHITE_SPACE;
+import static racingcar.View.ViewConstants.WINNER_IS;
+
+import java.util.List;
+
+public class OutputView {
+    public void printResultPhrase() {
+        System.out.println(System.lineSeparator() + RACE_RESULT);
+    }
+
+    public void printRaceProgress(String roundResult) {
+        System.out.println(roundResult);
+    }
+
+    public void printWinners(List<String> winnerNames) {
+        String winners = String.join(NAME_DELIMITER + WHITE_SPACE, winnerNames);
+        System.out.printf("%s%s", WINNER_IS, winners);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/racingcar/View/ViewConstants.java b/src/main/java/racingcar/View/ViewConstants.java
new file mode 100644
index 0000000000..b63123f8c3
--- /dev/null
+++ b/src/main/java/racingcar/View/ViewConstants.java
@@ -0,0 +1,31 @@
+package racingcar.View;
+
+import static racingcar.model.RacingConstants.MAX_LENGTH_OF_CAR_NAME;
+import static racingcar.model.RacingConstants.MIN_LENGTH_OF_CAR_NAME;
+import static racingcar.model.RacingConstants.MIN_ROUNDS;
+import static racingcar.model.RacingConstants.REQUIRED_MIN_PLAYERS;
+
+public class ViewConstants {
+    public static final String ENTER_CAR_NAMES_MESSAGE = "경주할 자동차 이름을 입력하세요.(이름은 쉼표(,) 기준으로 구분)";
+    public static final String ENTER_TOTAL_ROUNDS_MESSAGE = "시도할 횟수는 몇 회인가요?";
+
+    public static final String NAME_DELIMITER = ",";
+    public static final String TOTAL_ROUNDS_REGEX = "^[0-9]+$";
+
+    public static final String RACE_RESULT = "실행 결과";
+    public static final String RACE_DISPLAY_FORMAT = "%s : ";
+    public static final String MOVE_SYMBOL = "-";
+
+    public static final String WINNER_IS = "최종 우승자 : ";
+    public static final String WHITE_SPACE = " ";
+
+    public static final String NOT_ENOUGH_PLAYERS_ERROR_MESSAGE
+            = String.format("이름을 %s개 이상 입력해야 게임이 시작됩니다.", REQUIRED_MIN_PLAYERS);
+    public static final String NAME_LENGTH_ERROR_MESSAGE
+            = String.format("이름은 %s자 이상, %s자 이하만 가능합니다.", MIN_LENGTH_OF_CAR_NAME, MAX_LENGTH_OF_CAR_NAME);
+    public static final String DUPLICATE_NAME_ERROR_MESSAGE = "중복된 이름은 사용할 수 없습니다.";
+
+    public static final String CONTAINS_NON_DIGIT_ERROR_MESSAGE = "시도 횟수는 숫자만 입력해 주세요.";
+    public static final String LESS_THAN_MIN_ROUNDS_ERROR_MESSAGE
+            = String.format("시도 횟수는 %s회 이상이어야 합니다.", MIN_ROUNDS);
+}
diff --git a/src/main/java/racingcar/config/AppConfig.java b/src/main/java/racingcar/config/AppConfig.java
new file mode 100644
index 0000000000..ca573d1476
--- /dev/null
+++ b/src/main/java/racingcar/config/AppConfig.java
@@ -0,0 +1,55 @@
+package racingcar.config;
+
+import racingcar.View.InputValidator;
+import racingcar.model.CarRacing;
+import racingcar.controller.CarRacingController;
+import racingcar.model.Racers;
+import racingcar.model.RacingRule;
+import racingcar.View.InputView;
+import racingcar.View.OutputView;
+import racingcar.service.CarRacingService;
+
+public class AppConfig {
+    public InputView inputView() {
+        return new InputView();
+    }
+
+    public InputValidator inputValidator() {
+        return new InputValidator();
+    }
+
+    public OutputView outputView() {
+        return new OutputView();
+    }
+
+    public CarRacingController carRacingController() {
+        return new CarRacingController(inputView(), inputValidator(), outputView());
+    }
+
+    public CarRacingService carRacingService() {
+        return new CarRacingService();
+    }
+
+    public RacingRule racingRule() {
+        return carRacingService().setRacingRule();
+    }
+
+    public Racers racers() {
+        return carRacingService().registerRacers(carRacingController().extractCarNames());
+    }
+
+    public int totalRounds() {
+        return carRacingService().registerTotalRounds(carRacingController().convertToNumber());
+    }
+
+    public CarRacing carRacing() {
+        return new CarRacing(racingRule(), racers());
+    }
+
+    public void run() {
+        CarRacingController carRacingController = carRacingController();
+        CarRacing carRacing = carRacing();
+        carRacingController.deliverRaceProgress(carRacing, totalRounds());
+        carRacingController.deliverWinners(carRacing);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/racingcar/controller/CarRacingController.java b/src/main/java/racingcar/controller/CarRacingController.java
new file mode 100644
index 0000000000..f16d2b6931
--- /dev/null
+++ b/src/main/java/racingcar/controller/CarRacingController.java
@@ -0,0 +1,57 @@
+package racingcar.controller;
+
+import static racingcar.View.ViewConstants.NAME_DELIMITER;
+
+import java.util.Arrays;
+import java.util.List;
+import racingcar.View.InputView;
+import racingcar.View.OutputView;
+import racingcar.View.InputValidator;
+import racingcar.model.CarRacing;
+
+public class CarRacingController {
+    private final InputView inputView;
+    private final InputValidator inputValidator;
+    private final OutputView outputView;
+
+    public CarRacingController(InputView inputView, InputValidator inputValidator, OutputView outputView) {
+        this.inputView = inputView;
+        this.inputValidator = inputValidator;
+        this.outputView = outputView;
+    }
+
+    public List<String> extractCarNames() {
+        String input = inputView.requestCarNames();
+        return splitByDelimiter(input);
+    }
+
+    private List<String> splitByDelimiter(String input) {
+        return Arrays.stream(input.split(NAME_DELIMITER)).toList();
+    }
+
+    public int convertToNumber() {
+        String input = inputView.requestTotalRounds();
+        inputValidator.validateThatContainsOnlyDigits(input);
+        return Integer.parseInt(input);
+    }
+
+    public void deliverRaceProgress(CarRacing carRacing, int totalRounds) {
+        outputView.printResultPhrase();
+        for (int i = 0; i < totalRounds; i++) {
+            List<String> currentResults = carRacing.playARound();
+            outputView.printRaceProgress(convertToString(currentResults));
+        }
+    }
+
+    private String convertToString(List<String> currentResults) {
+        StringBuilder output = new StringBuilder();
+        for (String result : currentResults) {
+            output.append(result).append(System.lineSeparator());
+        }
+        return output.toString();
+    }
+
+    public void deliverWinners(CarRacing carRacing) {
+        outputView.printWinners(carRacing.announceWinners());
+    }
+}
diff --git a/src/main/java/racingcar/model/Car.java b/src/main/java/racingcar/model/Car.java
new file mode 100644
index 0000000000..826976b030
--- /dev/null
+++ b/src/main/java/racingcar/model/Car.java
@@ -0,0 +1,48 @@
+package racingcar.model;
+
+import static racingcar.model.RacingConstants.MAX_LENGTH_OF_CAR_NAME;
+import static racingcar.View.ViewConstants.MOVE_SYMBOL;
+import static racingcar.View.ViewConstants.NAME_LENGTH_ERROR_MESSAGE;
+import static racingcar.View.ViewConstants.RACE_DISPLAY_FORMAT;
+
+public class Car implements Comparable<Car> {
+    private final String name;
+    private int moveCount;
+
+    public Car(String name, int moveCount) {
+        validateLengthOf(name);
+        this.name = name;
+        this.moveCount = moveCount;
+    }
+
+    private void validateLengthOf(String name) {
+        if (name == null || name.isBlank() || (name.length() > MAX_LENGTH_OF_CAR_NAME)) {
+            throw new IllegalArgumentException(NAME_LENGTH_ERROR_MESSAGE);
+        }
+    }
+
+    public int moveForwardIf(boolean possible) {
+        if (possible) {
+            moveCount++;
+            return moveCount;
+        }
+        return -1;
+    }
+
+    public boolean isSameMoveCount(Car other) {
+        return other.moveCount == this.moveCount;
+    }
+
+    @Override
+    public int compareTo(Car other) {
+        return this.moveCount - other.moveCount;
+    }
+
+    public String getStatus() {
+        return String.format(RACE_DISPLAY_FORMAT, name).concat(MOVE_SYMBOL.repeat(moveCount));
+    }
+
+    public String getName() {
+        return name;
+    }
+}
diff --git a/src/main/java/racingcar/model/CarRacing.java b/src/main/java/racingcar/model/CarRacing.java
new file mode 100644
index 0000000000..79f1847b2c
--- /dev/null
+++ b/src/main/java/racingcar/model/CarRacing.java
@@ -0,0 +1,22 @@
+package racingcar.model;
+
+import java.util.List;
+
+public class CarRacing {
+    private final RacingRule racingRule;
+    private final Racers racers;
+
+    public CarRacing(RacingRule racingRule, Racers racers) {
+        this.racingRule = racingRule;
+        this.racers = racers;
+    }
+
+    public List<String> playARound() {
+        racers.tryToMoveWith(racingRule);
+        return racers.getCurrentResult();
+    }
+
+    public List<String> announceWinners() {
+        return racers.getWinnerNames();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/racingcar/model/Racers.java b/src/main/java/racingcar/model/Racers.java
new file mode 100644
index 0000000000..b364c022cc
--- /dev/null
+++ b/src/main/java/racingcar/model/Racers.java
@@ -0,0 +1,60 @@
+package racingcar.model;
+
+import static racingcar.View.ViewConstants.DUPLICATE_NAME_ERROR_MESSAGE;
+import static racingcar.View.ViewConstants.NOT_ENOUGH_PLAYERS_ERROR_MESSAGE;
+import static racingcar.model.RacingConstants.REQUIRED_MIN_PLAYERS;
+
+import java.util.List;
+
+public class Racers {
+    private final List<Car> cars;
+
+    public Racers(List<Car> cars) {
+        validateCountOf(cars);
+        validateNonDuplicate(cars);
+        this.cars = cars;
+    }
+
+    private void validateCountOf(List<Car> cars) {
+        if (cars.size() < REQUIRED_MIN_PLAYERS) {
+            throw new IllegalArgumentException(NOT_ENOUGH_PLAYERS_ERROR_MESSAGE);
+        }
+    }
+
+    private void validateNonDuplicate(List<Car> cars) {
+        long totalDistinctNames = cars.stream().map(Car::getName).distinct().count();
+        if (cars.size() != totalDistinctNames) {
+            throw new IllegalArgumentException(DUPLICATE_NAME_ERROR_MESSAGE);
+        }
+    }
+
+    public void tryToMoveWith(RacingRule racingRule) {
+        for (Car car : cars) {
+            car.moveForwardIf(racingRule.permitToMove());
+        }
+    }
+
+    public List<String> getCurrentResult() {
+        return cars.stream()
+                .map(Car::getStatus)
+                .toList();
+    }
+
+    public List<String> getWinnerNames() {
+        Car maxMoveCountCar = findMaxMoveCountCar();
+        return findSameMoveCountCar(maxMoveCountCar);
+    }
+
+    private List<String> findSameMoveCountCar(Car maxMoveCountCar) {
+        return cars.stream()
+                .filter(maxMoveCountCar::isSameMoveCount)
+                .map(Car::getName)
+                .toList();
+    }
+
+    private Car findMaxMoveCountCar() {
+        return cars.stream()
+                .max(Car::compareTo)
+                .orElseThrow();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/racingcar/model/RacingConstants.java b/src/main/java/racingcar/model/RacingConstants.java
new file mode 100644
index 0000000000..cc7257a9f4
--- /dev/null
+++ b/src/main/java/racingcar/model/RacingConstants.java
@@ -0,0 +1,14 @@
+package racingcar.model;
+
+public class RacingConstants {
+    public static final int REQUIRED_MIN_PLAYERS = 2;
+    public static final int MIN_ROUNDS = 1;
+
+    public static final int MIN_LENGTH_OF_CAR_NAME = 1;
+    public static final int MAX_LENGTH_OF_CAR_NAME = 5;
+    public static final int INITIAL_MOVE_COUNT = 0;
+
+    public static final int MIN_NUMBER_TO_MOVE = 4;
+    public static final int MIN_NUMBER_IN_RANGE = 0;
+    public static final int MAX_NUMBER_IN_RANGE = 9;
+}
\ No newline at end of file
diff --git a/src/main/java/racingcar/model/RacingRule.java b/src/main/java/racingcar/model/RacingRule.java
new file mode 100644
index 0000000000..0d178e9fd1
--- /dev/null
+++ b/src/main/java/racingcar/model/RacingRule.java
@@ -0,0 +1,27 @@
+package racingcar.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+public class RacingRule {
+    private final int minNumber;
+    private final int maxNumber;
+    private final int minNumberToMove;
+
+    public RacingRule(int minNumber, int maxNumber, int minNumberToMove) {
+        this.minNumber = minNumber;
+        this.maxNumber = maxNumber;
+        this.minNumberToMove = minNumberToMove;
+    }
+
+    public boolean permitToMove() {
+        return isMovable(pickRandomNumber());
+    }
+
+    private int pickRandomNumber() {
+        return Randoms.pickNumberInRange(minNumber, maxNumber);
+    }
+
+    private boolean isMovable(int number) {
+        return number >= minNumberToMove;
+    }
+}
diff --git a/src/main/java/racingcar/service/CarRacingService.java b/src/main/java/racingcar/service/CarRacingService.java
new file mode 100644
index 0000000000..331c5ba389
--- /dev/null
+++ b/src/main/java/racingcar/service/CarRacingService.java
@@ -0,0 +1,36 @@
+package racingcar.service;
+
+import static racingcar.View.ViewConstants.LESS_THAN_MIN_ROUNDS_ERROR_MESSAGE;
+import static racingcar.model.RacingConstants.INITIAL_MOVE_COUNT;
+import static racingcar.model.RacingConstants.MAX_NUMBER_IN_RANGE;
+import static racingcar.model.RacingConstants.MIN_NUMBER_IN_RANGE;
+import static racingcar.model.RacingConstants.MIN_NUMBER_TO_MOVE;
+import static racingcar.model.RacingConstants.MIN_ROUNDS;
+
+import java.util.List;
+import racingcar.model.Car;
+import racingcar.model.Racers;
+import racingcar.model.RacingRule;
+
+public class CarRacingService {
+    public RacingRule setRacingRule() {
+        return new RacingRule(MIN_NUMBER_IN_RANGE, MAX_NUMBER_IN_RANGE, MIN_NUMBER_TO_MOVE);
+    }
+
+    public Racers registerRacers(List<String> carNames) {
+        return new Racers(carNames.stream()
+                .map(name -> new Car(name, INITIAL_MOVE_COUNT))
+                .toList());
+    }
+
+    public int registerTotalRounds(int number) {
+        validateMinRoundsOrOver(number);
+        return number;
+    }
+
+    private void validateMinRoundsOrOver(int number) {
+        if (number < MIN_ROUNDS) {
+            throw new IllegalArgumentException(LESS_THAN_MIN_ROUNDS_ERROR_MESSAGE);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/racingcar/model/CarTest.java b/src/test/java/racingcar/model/CarTest.java
new file mode 100644
index 0000000000..22d779f9c0
--- /dev/null
+++ b/src/test/java/racingcar/model/CarTest.java
@@ -0,0 +1,61 @@
+package racingcar.model;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static racingcar.model.RacingConstants.INITIAL_MOVE_COUNT;
+import static racingcar.model.RacingConstants.MAX_LENGTH_OF_CAR_NAME;
+import static racingcar.model.RacingConstants.MIN_LENGTH_OF_CAR_NAME;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class CarTest {
+    @DisplayName("최소 길이보다 짧은 이름을 전달받으면 예외 발생")
+    @ParameterizedTest
+    @ValueSource(strings = {"    "})
+    @NullAndEmptySource
+    void throwExceptionIfGetNameShorterThanMinLength(String name) {
+        assertThatThrownBy(() -> new Car(name, INITIAL_MOVE_COUNT))
+                .isExactlyInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining(String.valueOf(MIN_LENGTH_OF_CAR_NAME));
+    }
+
+    @DisplayName("최대 길이보다 긴 이름을 전달받으면 예외 발생")
+    @ParameterizedTest
+    @ValueSource(strings = {"sarang", "sarangkim", "jaesungpark", "가나다라마바"})
+    void throwExceptionIfGetNameLongerThanMaxLength(String name) {
+        assertThatThrownBy(() -> new Car(name, INITIAL_MOVE_COUNT))
+                .isExactlyInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining(String.valueOf(MAX_LENGTH_OF_CAR_NAME));
+    }
+
+    @DisplayName("전달받은 이름의 길이가 유효하면 Car 인스턴스 생성")
+    @ParameterizedTest
+    @ValueSource(strings = {"k", "go123", "pobi", "saera", "won.i", "차", "아자", "카타파하5"})
+    void createCar(String name) {
+        assertThat(new Car(name, INITIAL_MOVE_COUNT)).isExactlyInstanceOf(Car.class);
+    }
+
+    @DisplayName("true를 전달받으면 위치값 반환")
+    @Test
+    void returnPositionIfGetTrue() {
+        Car car = new Car("pobi", INITIAL_MOVE_COUNT);
+
+        int actual = car.moveForwardIf(true);
+
+        assertThat(actual).isEqualTo(INITIAL_MOVE_COUNT + 1);
+    }
+
+    @DisplayName("false를 전달받으면 -1 반환")
+    @Test
+    void returnMinusOneIfGetFalse() {
+        Car car = new Car("pobi", INITIAL_MOVE_COUNT);
+
+        int actual = car.moveForwardIf(false);
+
+        assertThat(actual).isEqualTo(-1);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/racingcar/model/RacersTest.java b/src/test/java/racingcar/model/RacersTest.java
new file mode 100644
index 0000000000..afb04c4535
--- /dev/null
+++ b/src/test/java/racingcar/model/RacersTest.java
@@ -0,0 +1,68 @@
+package racingcar.model;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static racingcar.View.ViewConstants.DUPLICATE_NAME_ERROR_MESSAGE;
+import static racingcar.View.ViewConstants.NAME_DELIMITER;
+import static racingcar.model.RacingConstants.REQUIRED_MIN_PLAYERS;
+
+import java.util.Arrays;
+import java.util.List;
+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 racingcar.service.CarRacingService;
+
+class RacersTest {
+    private final CarRacingService carRacingService = new CarRacingService();
+    private List<String> inputNames;
+
+    @DisplayName("입력된 자동차 이름이 2개 미만이면 예외 발생")
+    @ParameterizedTest
+    @ValueSource(strings = {",", ",,,,,", "pobi", "ab.cd", "jo ko"})
+    void throwExceptionIfPlayersNotEnough(String input) {
+        inputNames = split(input);
+
+        assertThatThrownBy(() -> carRacingService.registerRacers(inputNames))
+                .isExactlyInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining(String.valueOf(REQUIRED_MIN_PLAYERS));
+    }
+
+    @DisplayName("입력된 자동차 이름에 중복이 있으면 예외 발생")
+    @ParameterizedTest
+    @ValueSource(strings = {"pobi,woni,jun,pobi", "가,가,가,가", "a,b,a,d,a,e,f", "0,0"})
+    void throwExceptionWhenDuplicateNameIsIn(String input) {
+        inputNames = split(input);
+
+        assertThatThrownBy(() -> carRacingService.registerRacers(inputNames))
+                .isExactlyInstanceOf(IllegalArgumentException.class)
+                .hasMessageMatching(DUPLICATE_NAME_ERROR_MESSAGE);
+    }
+
+    @DisplayName("입력된 자동차 이름이 2개 이상이고, 중복이 없으면 Racers 인스턴스 생성")
+    @ParameterizedTest
+    @ValueSource(strings = {"pobi,jun", "pobi,jun,woni", "가,나", "가나다라마,바사아자차,카타파하", "kim1,kim2,kim3,kim4,kim5"})
+    void createRacers(String input) {
+        inputNames = split(input);
+
+        assertThat(carRacingService.registerRacers(inputNames)).isExactlyInstanceOf(Racers.class);
+    }
+
+    private List<String> split(String input) {
+        return Arrays.stream(input.split(NAME_DELIMITER)).toList();
+    }
+
+    @DisplayName("getWinnerNames() 메서드가 우승자들의 이름을 반환한다.")
+    @Test
+    void returnWinnerNames() {
+        Racers racers = new Racers(List.of(
+                new Car("pobi", Integer.MAX_VALUE), new Car("woni", 4), new Car("jun", Integer.MAX_VALUE)
+        ));
+
+        List<String> actual = racers.getWinnerNames();
+        List<String> expected = List.of("pobi", "jun");
+
+        assertThat(actual).isEqualTo(expected);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/racingcar/service/CarRacingServiceTest.java b/src/test/java/racingcar/service/CarRacingServiceTest.java
new file mode 100644
index 0000000000..efd4d17c8d
--- /dev/null
+++ b/src/test/java/racingcar/service/CarRacingServiceTest.java
@@ -0,0 +1,35 @@
+package racingcar.service;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static racingcar.View.ViewConstants.LESS_THAN_MIN_ROUNDS_ERROR_MESSAGE;
+import static racingcar.model.RacingConstants.MIN_ROUNDS;
+
+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;
+
+class CarRacingServiceTest {
+
+    @DisplayName("최소 시도 횟수보다 작은 값을 전달받으면 예외 발생")
+    @Test
+    void throwExceptionIfNumberIsLessThanMinRounds() {
+        CarRacingService carRacingService = new CarRacingService();
+
+        int number = MIN_ROUNDS - 1;
+
+        assertThatThrownBy(() -> carRacingService.registerTotalRounds(number))
+                .isExactlyInstanceOf(IllegalArgumentException.class)
+                .hasMessageMatching(LESS_THAN_MIN_ROUNDS_ERROR_MESSAGE);
+    }
+
+    @DisplayName("최소 시도 횟수보다 크거나 같은 값을 전달받으면 그 값을 반환")
+    @ParameterizedTest
+    @ValueSource(ints = {MIN_ROUNDS, MIN_ROUNDS + 1, 1, 2, 3, 10, 1000, Integer.MAX_VALUE})
+    void returnTotalRoundsIfNumberIsAboveMinRounds(int number) {
+        CarRacingService carRacingService = new CarRacingService();
+
+        assertThat(carRacingService.registerTotalRounds(number)).isEqualTo(number);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/racingcar/view/InputValidatorTest.java b/src/test/java/racingcar/view/InputValidatorTest.java
new file mode 100644
index 0000000000..af0a9c5d3d
--- /dev/null
+++ b/src/test/java/racingcar/view/InputValidatorTest.java
@@ -0,0 +1,26 @@
+package racingcar.view;
+
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import racingcar.View.InputValidator;
+
+class InputValidatorTest {
+    @DisplayName("숫자로만 구성된 문자열이면 통과")
+    @ParameterizedTest
+    @ValueSource(strings = {"0", "1", "0123456789"})
+    void passWhenInputHasNumbersOnly(String input) {
+        assertThatCode(() -> new InputValidator().validateThatContainsOnlyDigits(input)).doesNotThrowAnyException();
+    }
+
+    @DisplayName("문자열에 숫자가 아닌 문자가 있으면 예외 발생")
+    @ParameterizedTest
+    @ValueSource(strings = {"", "0회", "1,", ";2", "34번", "56회 시도"})
+    void throwIllegalArgumentExceptionWhenInputHasNotNumbersOnly(String input) {
+        assertThatThrownBy(() -> new InputValidator().validateThatContainsOnlyDigits(input))
+                .isExactlyInstanceOf(IllegalArgumentException.class);
+    }
+}
\ No newline at end of file