diff --git a/src/README.md b/src/README.md
new file mode 100644
index 00000000..640ddc5f
--- /dev/null
+++ b/src/README.md
@@ -0,0 +1,54 @@
+# 사다리 게임
+
+## 💡 기능 요구사항
+
+1. 사다리 게임에 참여하는 사람에 이름을 최대 5글자까지 부여할 수 있다.
+2. 사다리를 출력할 때 사람 이름도 같이 출력한다.
+3. 사람 이름은 쉼표(,)를 기준으로 구분한다.
+4. 개인별 이름을 입력하면 개인별 결과를 출력한다.
+5. `"all"`을 입력하면 전체 참여자의 실행 결과를 출력한다.
+
+---
+
+## 클래스 소개
+
+| 클래스                        | 역할|
+|----------------------------|---|
+| `Name`                     | 이름 단위를 표현 |
+| `Names`                    | 이름들의 일급 컬렉션 |
+| `Players`                  | 참가자 이름 목록 관리 및 중복 제거 |
+| `Results`                  | 실행 결과 목록 관리 |
+| `Height`                   | 사다리 높이 검증 및 저장 |
+| `Connect`                  | `CONNECTED` / `DISCONNECTED` 상태 Enum |
+| `Point`                    | 연결 여부(`Connect`) 표현 |
+| `Line`                     | 한 줄의 연결 상태(`Point`) 관리 |
+| `Ladder`                   | 사다리 전체를 구성 (여러 Line의 집합) |
+| `LadderGame`               | 이동 로직 및 결과 매핑 수행 |
+| `LadderController`         | 전체 게임 실행 흐름 제어 |
+| `InputView` / `OutputView` | 입출력 담당 |
+| `Main`                     | 프로그램 실행의 진입점 담당 |
+
+---
+
+## 프로그램 실행 흐름
+
+1. **입력 단계**
+    - 참여자 이름, 실행 결과, 사다리 높이를 순서대로 입력받는다.
+    - 이름과 결과의 개수가 다르면 예외를 발생시킨다.
+    - 이름이 5글자를 초과하면 예외를 발생한다.
+    - 사다리 높이가 양수가 아니거나 숫자가 아닌 입력이 들어오면 예외를 발생시킨다.
+
+---
+
+2. **사다리 생성 단계**
+    - 입력받은 높이와 인원 수를 기반으로 `Ladder` 객체를 생성한다.
+    - 내부적으로 `Line.create()`를 호출하여 각 Line의 연결 상태를 무작위로 생성한다.
+    - 높이가 0인 경우에도 1줄의 사다리가 생성된다.
+
+---
+
+3. **결과 조회 단계**
+    - 사용자가 이름을 입력하면 해당 참가자의 결과를 출력한다.
+    - `"all"`을 입력하면 전체 참가자의 결과를 한 번에 출력한다.
+
+---
diff --git a/src/main/java/Main.java b/src/main/java/Main.java
new file mode 100644
index 00000000..0b99e6e8
--- /dev/null
+++ b/src/main/java/Main.java
@@ -0,0 +1,22 @@
+import controller.LadderController;
+import domain.LadderGame;
+import domain.Players;
+import domain.Results;
+import view.InputView;
+import view.OutputView;
+
+public class Main {
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        LadderController controller = new LadderController(inputView, outputView);
+
+        Players players = controller.inputPlayers();
+        Results results = controller.inputResults(players);
+        int height = controller.inputHeight();
+
+        LadderGame game = controller.startLadderGame(height, players, results);
+        controller.showResult(game, players);
+
+    }
+}
diff --git a/src/main/java/controller/LadderController.java b/src/main/java/controller/LadderController.java
new file mode 100644
index 00000000..4b073d33
--- /dev/null
+++ b/src/main/java/controller/LadderController.java
@@ -0,0 +1,104 @@
+package controller;
+
+import domain.Ladder;
+import domain.LadderGame;
+import domain.PlayerName;
+import domain.Players;
+import domain.ResultName;
+import domain.Results;
+import view.InputView;
+import view.OutputView;
+
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.util.List;
+import java.util.Random;
+
+public class LadderController {
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public LadderController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public Players inputPlayers() {
+        outputView.printAskPlayers();
+        while (true) {
+            try {
+                String input = inputView.readString();
+                List<PlayerName> players = Arrays.stream(input.split(","))
+                        .map(String::trim)
+                        .map(PlayerName::new)
+                        .toList();
+                return new Players(players);
+            } catch (IllegalArgumentException e) {
+                outputView.printException(e);
+                outputView.printRetryInputMessage();
+            }
+        }
+    }
+
+    public Results inputResults(Players players) {
+        outputView.printAskResults();
+        while (true) {
+            try {
+                String input = inputView.readString();
+                List<ResultName> result = Arrays.stream(input.split(","))
+                        .map(String::trim)
+                        .map(ResultName::new)
+                        .toList();
+                Results results = new Results(result);
+                LadderGame.validatePlayerAndResultCount(players, results);
+                return results;
+            } catch (IllegalArgumentException e) {
+                outputView.printException(e);
+                outputView.printRetryInputMessage();
+            }
+        }
+    }
+
+    public int inputHeight() {
+        outputView.printAskHeight();
+        while (true) {
+            try {
+                int height = inputView.readInt();
+                if (height < 0) {
+                    throw new IllegalArgumentException("높이는 양수여야 합니다.");
+                }
+                return height;
+            } catch (InputMismatchException | IllegalArgumentException e) {
+                outputView.printException(e);
+                outputView.printRetryInputMessage();
+            }
+        }
+    }
+
+    public LadderGame startLadderGame(int height, Players players, Results results) {
+        Ladder ladder = new Ladder(height, players.size(), new Random());
+        LadderGame game = new LadderGame(ladder, players, results);
+        outputView.printLadderResultTitle();
+        outputView.printLadder(ladder, players.getPlayers(), results.getResults());
+        return game;
+    }
+
+    public void showResult(LadderGame game, Players players) {
+        boolean run = true;
+        while (run) {
+            outputView.printAskResultByPlayer();
+            String name = inputView.readString();
+            run = validateRun(game, players, name);
+        }
+    }
+
+    private boolean validateRun(LadderGame game, Players players, String name) {
+        if (name.equals("all")) {
+            outputView.printAllResults(game.findAll(), players);
+            return false;
+        }
+        String result = game.findResultByPlayer(name);
+        outputView.printSingleResult(result);
+        return true;
+    }
+}
diff --git a/src/main/java/domain/Connect.java b/src/main/java/domain/Connect.java
new file mode 100644
index 00000000..b087e5ce
--- /dev/null
+++ b/src/main/java/domain/Connect.java
@@ -0,0 +1,44 @@
+package domain;
+
+public enum Connect {
+    CONNECTED(true) {
+        @Override
+        public int moveRight(int index) {
+            return index + 1;
+        }
+
+        @Override
+        public int moveLeft(int index) {
+            return index - 1;
+        }
+    },
+    DISCONNECTED(false) {
+        @Override
+        public int moveRight(int index) {
+            return index;
+        }
+
+        @Override
+        public int moveLeft(int index) {
+            return index;
+        }
+    };
+
+    private final boolean value;
+
+    Connect(boolean value) {
+        this.value = value;
+    }
+
+    public abstract int moveRight(int index);
+
+    public abstract int moveLeft(int index);
+
+    public boolean isConnected() {
+        return value;
+    }
+
+    public static Connect from(boolean value) {
+        return value ? CONNECTED : DISCONNECTED;
+    }
+}
diff --git a/src/main/java/domain/Ladder.java b/src/main/java/domain/Ladder.java
new file mode 100644
index 00000000..f60bb7d5
--- /dev/null
+++ b/src/main/java/domain/Ladder.java
@@ -0,0 +1,25 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class Ladder {
+    private final List<Line> lines;
+
+    public Ladder(int height, int playerCount, Random random) {
+        List<Line> temp = new ArrayList<>();
+
+        for (int i = 0; i < height; i++) {
+            temp.add(Line.create(playerCount, random));
+        }
+        if (height == 0) {
+            temp.add(Line.create(playerCount, random));
+        }
+        this.lines = List.copyOf(temp);
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+}
diff --git a/src/main/java/domain/LadderGame.java b/src/main/java/domain/LadderGame.java
new file mode 100644
index 00000000..5655098f
--- /dev/null
+++ b/src/main/java/domain/LadderGame.java
@@ -0,0 +1,52 @@
+package domain;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LadderGame {
+    private final Ladder ladder;
+    private final Players players;
+    private final Results results;
+
+    public LadderGame(Ladder ladder, Players players, Results results) {
+        this.ladder = ladder;
+        this.players = players;
+        this.results = results;
+    }
+
+    public static void validatePlayerAndResultCount(Players players, Results results) {
+        if (players.size() != results.size()) {
+            throw new IllegalArgumentException("참가자와 결과 수는 같아야 합니다.");
+        }
+    }
+
+    private int move(int position) {
+        for (Line line : ladder.getLines()) {
+            position = line.moveOf(position);
+        }
+        return position;
+    }
+
+
+    public String findResultByPlayer(String name) {
+        List<PlayerName> player = players.getPlayers();
+        List<ResultName> result = results.getResults();
+
+        int index = player.indexOf(new PlayerName(name));
+        if (index < 0) {
+            throw new IllegalArgumentException("존재하지 않는 플레이어입니다.");
+        }
+        index = move(index);
+        return result.get(index).value();
+    }
+
+    public Map<String, String> findAll() {
+        Map<String, String> map = new HashMap<>();
+        List<PlayerName> player = players.getPlayers();
+        for (PlayerName name : player) {
+            map.put(name.value(), findResultByPlayer(name.value()));
+        }
+        return map;
+    }
+}
diff --git a/src/main/java/domain/Line.java b/src/main/java/domain/Line.java
new file mode 100644
index 00000000..751c5423
--- /dev/null
+++ b/src/main/java/domain/Line.java
@@ -0,0 +1,61 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class Line {
+    private final List<Connect> points;
+
+    private Line(List<Connect> points) {
+        this.points = List.copyOf(points);
+    }
+
+    static Line of(List<Connect> points) {
+        return new Line(points);
+    }
+
+    public static Line create(int playerCount, Random random) {
+        List<Connect> points = new ArrayList<>();
+        Connect prev = Connect.DISCONNECTED;
+
+        for (int i = 0; i < playerCount - 1; i++) {
+            Connect next = Connect.from(random.nextBoolean());
+            next = checkPrev(prev, next);
+            points.add(next);
+            prev = next;
+        }
+        return new Line(points);
+    }
+
+    private static Connect checkPrev(Connect prev, Connect next) {
+        if (prev.isConnected()) {
+            return Connect.DISCONNECTED;
+        }
+        return next;
+    }
+
+    private Connect rightOf(int index) {
+        if (index >= points.size()) return Connect.DISCONNECTED;
+        return points.get(index);
+    }
+
+    private Connect leftOf(int index) {
+        if (index <= 0) return Connect.DISCONNECTED;
+        return points.get(index - 1);
+    }
+
+    public int moveOf(int index) {
+        Connect right = rightOf(index);
+        if (right.isConnected()) return right.moveRight(index);
+
+        Connect left = leftOf(index);
+        if (left.isConnected()) return left.moveLeft(index);
+
+        return index;
+    }
+
+    public List<Connect> getPoints() {
+        return points;
+    }
+}
diff --git a/src/main/java/domain/PlayerName.java b/src/main/java/domain/PlayerName.java
new file mode 100644
index 00000000..1852fe4d
--- /dev/null
+++ b/src/main/java/domain/PlayerName.java
@@ -0,0 +1,43 @@
+package domain;
+
+public class PlayerName {
+    private static final int PLAYER_NAME_MAX_LENGTH = 5;
+    private final String value;
+
+    public PlayerName(String value) {
+        if (value == null) {
+            throw new IllegalArgumentException("플레이어 이름은 null일 수 없습니다.");
+        }
+        String trimmed = value.trim();
+        if (trimmed.isEmpty()) {
+            throw new IllegalArgumentException("플레이어 이름은 비어있을 수 없습니다.");
+        }
+
+        if (trimmed.length() > PLAYER_NAME_MAX_LENGTH) {
+            throw new IllegalArgumentException("플에이어 이름은 5글자를 넘으면 안됩니다.");
+        }
+        this.value = trimmed;
+    }
+
+    public String value() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof PlayerName)) return false;
+        PlayerName other = (PlayerName) obj;
+        return value.equals(other.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return value.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return value;
+    }
+}
diff --git a/src/main/java/domain/Players.java b/src/main/java/domain/Players.java
new file mode 100644
index 00000000..56a5b24d
--- /dev/null
+++ b/src/main/java/domain/Players.java
@@ -0,0 +1,29 @@
+package domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Players {
+    private final List<PlayerName> players;
+
+    public Players(List<PlayerName> players) {
+        validateDuplicate(players);
+        this.players = List.copyOf(players);
+    }
+
+    private void validateDuplicate(List<PlayerName> players) {
+        Set<PlayerName> set = new HashSet<>(players);
+        if (set.size() != players.size()) {
+            throw new IllegalArgumentException("플레이어 이름은 중복될 수 없습니다.");
+        }
+    }
+
+    public int size() {
+        return players.size();
+    }
+
+    public List<PlayerName> getPlayers() {
+        return players;
+    }
+}
diff --git a/src/main/java/domain/ResultName.java b/src/main/java/domain/ResultName.java
new file mode 100644
index 00000000..55938b32
--- /dev/null
+++ b/src/main/java/domain/ResultName.java
@@ -0,0 +1,39 @@
+package domain;
+
+public class ResultName {
+    private final String value;
+
+    public ResultName(String value) {
+        if (value == null) {
+            throw new IllegalArgumentException("결과 이름은 null일 수 없습니다.");
+        }
+        String trimmed = value.trim();
+        if (trimmed.isEmpty()) {
+            throw new IllegalArgumentException("결과 이름은 비어있을 수 없습니다.");
+        }
+
+        this.value = trimmed;
+    }
+
+    public String value() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof ResultName)) return false;
+        ResultName other = (ResultName) obj;
+        return value.equals(other.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return value.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return value;
+    }
+}
diff --git a/src/main/java/domain/Results.java b/src/main/java/domain/Results.java
new file mode 100644
index 00000000..fbf27ad0
--- /dev/null
+++ b/src/main/java/domain/Results.java
@@ -0,0 +1,19 @@
+package domain;
+
+import java.util.List;
+
+public class Results {
+    private final List<ResultName> results;
+
+    public Results(List<ResultName> results) {
+        this.results = List.copyOf(results);
+    }
+
+    public int size() {
+        return results.size();
+    }
+
+    public List<ResultName> getResults() {
+        return results;
+    }
+}
diff --git a/src/main/java/view/InputView.java b/src/main/java/view/InputView.java
new file mode 100644
index 00000000..de860c3a
--- /dev/null
+++ b/src/main/java/view/InputView.java
@@ -0,0 +1,18 @@
+package view;
+
+import java.util.Scanner;
+
+public class InputView {
+    Scanner input = new Scanner(System.in);
+
+    public String readString() {
+        return input.nextLine();
+    }
+
+    public int readInt() {
+        int number = input.nextInt();
+        input.nextLine();
+        return number;
+    }
+}
+
diff --git a/src/main/java/view/OutputView.java b/src/main/java/view/OutputView.java
new file mode 100644
index 00000000..0d2611e4
--- /dev/null
+++ b/src/main/java/view/OutputView.java
@@ -0,0 +1,100 @@
+package view;
+
+import domain.Connect;
+import domain.Ladder;
+import domain.Line;
+import domain.PlayerName;
+import domain.Players;
+import domain.ResultName;
+
+import java.util.List;
+import java.util.Map;
+
+public class OutputView {
+    public void printAskPlayers() {
+        System.out.println("참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)");
+    }
+
+    public void printAskResults() {
+        System.out.println("\n실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)");
+    }
+
+    public void printAskHeight() {
+        System.out.println("\n최대 사다리 높이는 몇 개인가요?");
+    }
+
+    public void printLadderResultTitle() {
+        System.out.println("\n사다리 결과\n");
+    }
+
+    public void printAskResultByPlayer() {
+        System.out.println("\n결과를 보고 싶은 사람은?");
+    }
+
+    public void printRetryInputMessage() {
+        System.out.println("다시 입력해주세요.");
+    }
+
+    public void printException(Exception e) {
+        if (e.getMessage() == null) {
+            System.out.println("숫자를 입력해주세요.");
+            return;
+        }
+        System.out.println(e.getMessage());
+    }
+
+    private void printPlayers(List<PlayerName> players) {
+        for (PlayerName name : players) {
+            System.out.printf("%6s", name);
+        }
+        System.out.println();
+    }
+
+    private void printResults(List<ResultName> results) {
+        for (ResultName result : results) {
+            System.out.printf("%6s", result);
+        }
+        System.out.println();
+    }
+
+    private void printLines(List<Line> lines) {
+        for (Line line : lines) {
+            System.out.print("      |");
+            printLine(line);
+            System.out.println();
+        }
+    }
+
+    private void printLine(Line line) {
+        for (Connect point : line.getPoints()) {
+            printPoint(point);
+        }
+    }
+
+    private void printPoint(Connect point) {
+        if (point.isConnected()) {
+            System.out.print("-----|");
+            return;
+        }
+        System.out.print("     |");
+    }
+
+    public void printLadder(Ladder ladder, List<PlayerName> players, List<ResultName> results) {
+        printPlayers(players);
+        printLines(ladder.getLines());
+        printResults(results);
+    }
+
+
+    public void printSingleResult(String result) {
+        System.out.println("\n실행 결과");
+        System.out.println(result);
+    }
+
+    public void printAllResults(Map<String, String> results, Players players) {
+        System.out.println("\n실행 결과");
+        for (PlayerName name : players.getPlayers()) {
+            System.out.println(name.value() + " : " + results.get(name.value()));
+        }
+    }
+}
diff --git a/src/test/java/domain/ConnectTest.java b/src/test/java/domain/ConnectTest.java
new file mode 100644
index 00000000..09e4ace5
--- /dev/null
+++ b/src/test/java/domain/ConnectTest.java
@@ -0,0 +1,63 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ConnectTest {
+    @Test
+    void from메서드_true면_CONNECTED_반환() {
+        //when
+        Connect value = Connect.from(true);
+
+        //then
+        assertThat(value).isEqualTo(Connect.CONNECTED);
+    }
+
+    @Test
+    void from메서드_true면_DISCONNECTED_반환() {
+        //when
+        Connect value = Connect.from(false);
+
+        //then
+        assertThat(value).isEqualTo(Connect.DISCONNECTED);
+    }
+
+    @Test
+    void CONNECTED_왼쪽으로_이동한다() {
+        //give
+        int index = 3;
+
+        //when
+        int result = Connect.CONNECTED.moveLeft(index);
+
+        //then
+        assertThat(result).isEqualTo(2);
+    }
+
+    @Test
+    void CONNECTED_오른쪽으로_이동한다() {
+        //give
+        int index = 3;
+
+        //when
+        int result = Connect.CONNECTED.moveRight(index);
+
+        //then
+        assertThat(result).isEqualTo(4);
+    }
+
+    @Test
+    void DISCONNECTED_제자리이다() {
+        //give
+        int index = 3;
+
+        //when
+        int result1 = Connect.DISCONNECTED.moveRight(index);
+        int result2 = Connect.DISCONNECTED.moveLeft(index);
+
+        //then
+        assertThat(result1).isEqualTo(3);
+        assertThat(result2).isEqualTo(3);
+    }
+}
diff --git a/src/test/java/domain/LadderGameTest.java b/src/test/java/domain/LadderGameTest.java
new file mode 100644
index 00000000..202932b2
--- /dev/null
+++ b/src/test/java/domain/LadderGameTest.java
@@ -0,0 +1,75 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class LadderGameTest {
+
+    @Test
+    void 참가자와_결과_수_불일치() {
+        //given
+        Players players = new Players(List.of(new PlayerName("태우"), new PlayerName("태우1")));
+        Results results = new Results(List.of(new ResultName("꽝")));
+
+        //when & then
+        assertThatThrownBy(() -> LadderGame.validatePlayerAndResultCount(players, results))
+                .isInstanceOf(IllegalArgumentException.class);
+
+    }
+
+    @Test
+    void 참가자_이름으로_결과를_조회할_수_있다() {
+        //given
+        Players players = new Players(List.of(new PlayerName("태우"), new PlayerName("태우1")));
+        Results results = new Results(List.of(new ResultName("꽝"), new ResultName("5000")));
+        int height = 2;
+        Ladder ladder = new Ladder(height, players.size(), new Random(1));
+        LadderGame game = new LadderGame(ladder, players, results);
+
+        //when
+        String result1 = game.findResultByPlayer("태우");
+        String result2 = game.findResultByPlayer("태우1");
+
+        //then
+        assertThat(result1).isIn("꽝", "5000");
+        assertThat(result2).isIn("꽝", "5000");
+    }
+
+    @Test
+    void all_입력시_모든_참가자와_그_결과가_나온다() {
+        //given
+        Players players = new Players(List.of(new PlayerName("태우"), new PlayerName("태우1")));
+        Results results = new Results(List.of(new ResultName("꽝"), new ResultName("5000")));
+        int height = 2;
+        Ladder ladder = new Ladder(height, players.size(), new Random(1));
+        LadderGame game = new LadderGame(ladder, players, results);
+
+        //when
+        Map<String, String> map = game.findAll();
+
+        //then
+        assertThat(map.keySet()).containsExactlyInAnyOrder("태우", "태우1");
+        assertThat(map.values()).containsExactlyInAnyOrder("꽝", "5000");
+    }
+
+    @Test
+    void 존재하지_않는_플레이어_조회시_예외() {
+        //given
+        Players players = new Players(List.of(new PlayerName("태우"), new PlayerName("태우1")));
+        Results results = new Results(List.of(new ResultName("꽝"), new ResultName("5000")));
+        int height = 2;
+        Ladder ladder = new Ladder(height, players.size(), new Random(1));
+        LadderGame game = new LadderGame(ladder, players, results);
+
+        // when & then
+        assertThatThrownBy(() -> game.findResultByPlayer("철수"))
+                .isInstanceOf(IllegalArgumentException.class);
+
+    }
+}
diff --git a/src/test/java/domain/LadderTest.java b/src/test/java/domain/LadderTest.java
new file mode 100644
index 00000000..1f0cec5b
--- /dev/null
+++ b/src/test/java/domain/LadderTest.java
@@ -0,0 +1,36 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Random;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LadderTest {
+    @Test
+    void 높이가_0인_사다리_생성() {
+        //given
+        int height = 0;
+        int playerCount = 3;
+
+        //when
+        Ladder ladder = new Ladder(height, playerCount, new Random(1));
+
+        //then
+        assertThat(ladder.getLines()).hasSize(1);
+    }
+
+    @Test
+    void 높이가_3인_사다리_생성() {
+        //given
+        int height = 3;
+        int playerCount = 3;
+
+        //when
+        Ladder ladder = new Ladder(height, playerCount, new Random(1));
+
+        //then
+        assertThat(ladder.getLines()).hasSize(3);
+    }
+
+}
diff --git a/src/test/java/domain/LineTest.java b/src/test/java/domain/LineTest.java
new file mode 100644
index 00000000..e02c7f15
--- /dev/null
+++ b/src/test/java/domain/LineTest.java
@@ -0,0 +1,107 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Random;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LineTest {
+    @Test
+    void 하나의_라인에_인접한_두_point가_CONNECTED이면_안된다() {
+        //givn
+        Random random = new Random(1);
+        int playerCount = 3;
+
+        //when
+        Line line = Line.create(playerCount, random);
+
+        //then
+        for (int i = 0; i < line.getPoints().size() - 1; i++) {
+            boolean prev = line.getPoints().get(i).isConnected();
+            boolean next = line.getPoints().get(i + 1).isConnected();
+            assertThat(prev && next).isFalse();
+        }
+    }
+
+    @Test
+    void 라인_마지막_인덱스면_오른쪽이동불가() {
+        //given
+        int index = 2;
+        Line line = Line.of(List.of(
+                Connect.CONNECTED,
+                Connect.DISCONNECTED
+        ));
+
+        //when
+        int result = line.moveOf(index);
+
+        //then
+        assertThat(result).isEqualTo(index);
+    }
+
+    @Test
+    void 라인_처음_인덱스면_왼쪽이동불가() {
+        //given
+        Line line = Line.of(List.of(
+                Connect.DISCONNECTED,
+                Connect.CONNECTED
+        ));
+        int index = 0;
+
+        //when
+        int result = line.moveOf(index);
+
+        //then
+        assertThat(result).isEqualTo(index);
+    }
+
+    @Test
+    void 오른쪽은_DISCONNECTED_왼쪽은_CONNECTED면_왼쪽_으로_이동한다() {
+        // given
+        Line line = Line.of(List.of(
+                Connect.DISCONNECTED,
+                Connect.CONNECTED
+        ));
+        int index = 2;
+
+        // when
+        int result = line.moveOf(index);
+
+        // then
+        assertThat(result).isEqualTo(1);
+    }
+
+    @Test
+    void 오른쪽은_CONNECTED_왼쪽은_DISCONNECTED면_오른쪽_으로_이동한다() {
+        // given
+        Line line = Line.of(List.of(
+                Connect.DISCONNECTED,
+                Connect.CONNECTED
+        ));
+        int index = 1;
+
+        // when
+        int result = line.moveOf(index);
+
+        // then
+        assertThat(result).isEqualTo(2);
+    }
+
+    @Test
+    void 양쪽모두_DISCONNECTED면_제자리() {
+        //give
+        Line line = Line.of(List.of(
+                Connect.DISCONNECTED,
+                Connect.DISCONNECTED
+        ));
+        int index = 1;
+
+        //when
+        int result = line.moveOf(index);
+
+        //then
+        assertThat(result).isEqualTo(index);
+    }
+}
diff --git a/src/test/java/domain/PlayerNameTest.java b/src/test/java/domain/PlayerNameTest.java
new file mode 100644
index 00000000..3247778b
--- /dev/null
+++ b/src/test/java/domain/PlayerNameTest.java
@@ -0,0 +1,42 @@
+package domain;
+
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class PlayerNameTest {
+    @Test
+    void null은_허용되지_않는다() {
+        // when & then
+        assertThatThrownBy(() -> new PlayerName(null))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    void 빈문자열은_허용되지_않는다() {
+        // when & then
+        assertThatThrownBy(() -> new PlayerName("   "))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    void 이름은_5글자를_초과할_수_없다() {
+        // when & then
+        assertThatThrownBy(() -> new PlayerName("태우태우태우"))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    void 정상_이름이면_생성된다() {
+        // given
+        String name = "태우";
+
+        // when
+        PlayerName playerName = new PlayerName(name);
+
+        // then
+        assertThat(playerName.value()).isEqualTo(name);
+    }
+}
diff --git a/src/test/java/domain/PlayersTest.java b/src/test/java/domain/PlayersTest.java
new file mode 100644
index 00000000..6cb596e0
--- /dev/null
+++ b/src/test/java/domain/PlayersTest.java
@@ -0,0 +1,33 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class PlayersTest {
+
+    @Test
+    void 플레이어_리스트를_생성할_수_있다() {
+        // given
+        List<PlayerName> list = List.of(new PlayerName("태우1"), new PlayerName("태우2"));
+
+        // when
+        Players players = new Players(list);
+
+        // then
+        assertThat(players.size()).isEqualTo(2);
+    }
+
+    @Test
+    void 중복된_이름이_있으면_예외() {
+        // given
+        List<PlayerName> list = List.of(new PlayerName("태우"), new PlayerName("태우"));
+
+        // when & then
+        assertThatThrownBy(() -> new Players(list))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}
diff --git a/src/test/java/domain/ResultNameTest.java b/src/test/java/domain/ResultNameTest.java
new file mode 100644
index 00000000..edd16a84
--- /dev/null
+++ b/src/test/java/domain/ResultNameTest.java
@@ -0,0 +1,35 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class ResultNameTest {
+    @Test
+    void null은_허용되지_않는다() {
+        // when & then
+        assertThatThrownBy(() -> new ResultName(null))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    void 빈문자열은_허용되지_않는다() {
+        // when & then
+        assertThatThrownBy(() -> new ResultName("   "))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+
+    @Test
+    void 정상_이름이면_생성된다() {
+        // given
+        String name = "태우";
+
+        // when
+        ResultName resultName = new ResultName(name);
+
+        // then
+        assertThat(resultName.value()).isEqualTo(name);
+    }
+}
diff --git a/src/test/java/domain/ResultsTest.java b/src/test/java/domain/ResultsTest.java
new file mode 100644
index 00000000..d81b82db
--- /dev/null
+++ b/src/test/java/domain/ResultsTest.java
@@ -0,0 +1,21 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ResultsTest {
+    @Test
+    void 결과_리스트를_생성할_수_있다() {
+        // given
+        List<ResultName> list = List.of(new ResultName("태우1"), new ResultName("태우2"));
+
+        // when
+        Results results = new Results(list);
+
+        // then
+        assertThat(results.size()).isEqualTo(2);
+    }
+}