diff --git a/README.md b/README.md
new file mode 100644
index 00000000..598ec25d
--- /dev/null
+++ b/README.md
@@ -0,0 +1,67 @@
+# 🪜 사다리 타기 게임 
+참가자의 이름과 원하는 결과를 입력하면 랜덤한 사다리를 생성하고, 
+각 사람이 어떤 결과에 도착하는지 확인할 수 있는 **사다리 게임**입니다.
+
+---
+
+## 🕹️ 사용 방법
+
+### 1. 참여자 이름 입력  
+- 최대 5글자까지 입력 가능합니다.
+- 이름은 쉼표 `,`로 구분해서 입력해야 합니다.
+- 입력한 순서대로 사다리 시작 위치가 지정됩니다.
+
+### 2. 실행 결과 입력  
+- 참여자 수와 같은 개수의 결과 입력해주세요.
+- 순서는 이름과 일치해야 합니다.
+- 입력한 순서대로 실행 결과 위치가 지정됩니다.
+
+### 3. 사다리 높이 입력  
+- 사다리의 세로 줄 수를 숫자로 입력해주세요.
+
+### 4. 생성된 사다리 확인 
+- 각 참여자의 시작 지점, 실행 결과 위치가 출력됩니다.
+
+### 5. 결과 확인  
+
+- 특정 이름을 입력하면 해당 사람의 결과가 출력됩니다.
+- `"all"`을 입력하면 전체 결과를 한 번에 확인할 수 있습니다.
+- `"all"`을 입력하면 모든 참여자의 최종 결과를 출력하고 프로그램이 종료됩니다.
+
+---
+## 🖥️ 실행 예시
+```
+참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)
+neo,brown,brie,tommy
+
+실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)
+꽝,5000,꽝,3000
+
+최대 사다리 높이는 몇 개인가요?
+5
+
+사다리 결과
+
+  neo brown brie  tommy
+    |-----|     |-----|
+    |     |-----|     |
+    |-----|     |     |
+    |     |-----|     |
+    |-----|     |-----|
+    꽝 5000      꽝 3000
+
+결과를 보고 싶은 사람은?
+neo
+
+실행 결과
+꽝
+
+결과를 보고 싶은 사람은?
+all
+
+실행 결과
+neo : 꽝
+brown : 3000
+brie : 꽝
+tommy : 5000
+```
diff --git a/src/main/java/LadderApplication.java b/src/main/java/LadderApplication.java
new file mode 100644
index 00000000..af1c3707
--- /dev/null
+++ b/src/main/java/LadderApplication.java
@@ -0,0 +1,14 @@
+import controller.LadderController;
+import view.InputView;
+import view.OutputView;
+
+public class LadderApplication {
+
+    public static void main(String[] args) {
+        InputView inputview = new InputView();
+        OutputView outputview = new OutputView();
+
+        LadderController ladderController = new LadderController(inputview, outputview);
+        ladderController.run();
+    }
+}
diff --git a/src/main/java/controller/LadderController.java b/src/main/java/controller/LadderController.java
new file mode 100644
index 00000000..936c7732
--- /dev/null
+++ b/src/main/java/controller/LadderController.java
@@ -0,0 +1,74 @@
+package controller;
+
+import domain.*;
+import view.InputView;
+import view.OutputView;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class LadderController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public LadderController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public void run() {
+        System.out.println("Starting Ladder Game..."); // 초기 진입 확인
+
+        Players players = readPlayers();
+        ResultItems resultItems = readResultItems(players.count());
+        LadderHeight height = inputView.readHeight();
+        LadderGame ladderGame = LadderGame.of(players.count(), height, new RandomGenerator());
+
+        List<String> playerNames = players.extractNames();
+        List<String> resultItemNames = resultItems.extractNames();
+        outputView.printLadder(playerNames, ladderGame, resultItemNames);
+
+        String requestName = inputView.readResultRequest();
+        handleResultRequest(requestName, players, ladderGame, resultItems);
+    }
+
+    private Players readPlayers() {
+        List<String> names = inputView.readPlayerNames();
+        List<Player> players = names.stream()
+                .map(Player::new)
+                .toList();
+        return new Players(players);
+    }
+
+    private ResultItems readResultItems(int expectedSize) {
+        List<String> results = inputView.readResultItems();
+        List<ResultItem> resultItems = results.stream()
+                .map(ResultItem::new)
+                .toList();
+        return new ResultItems(resultItems, expectedSize);
+    }
+
+    private void handleResultRequest(String request, Players players, LadderGame ladder, ResultItems resultItems) {
+        LadderGameResult gameResult = new LadderGameResult(players, resultItems, ladder);
+
+        while (!request.equals("all")) {
+            try {
+                Player player = new Player(request);
+                outputView.printSingleResult(player.getName(), gameResult.getSingleResultFor(player).getItem());
+            } catch (IllegalArgumentException e) {
+                System.out.println("잘못된 이름입니다. 다시 입력해주세요.");
+            }
+            request = inputView.readResultRequest();
+        }
+
+        Map<String, String> resultMap = gameResult.getAllResults().entrySet().stream()
+                .collect(Collectors.toMap(
+                        entry -> entry.getKey().getName(),
+                        entry -> entry.getValue().getItem()
+                ));
+
+        outputView.printAllResults(resultMap);
+    }
+}
diff --git a/src/main/java/domain/LadderGame.java b/src/main/java/domain/LadderGame.java
new file mode 100644
index 00000000..dddbc76c
--- /dev/null
+++ b/src/main/java/domain/LadderGame.java
@@ -0,0 +1,24 @@
+package domain;
+
+import java.util.List;
+
+public class LadderGame {
+
+    private final LadderLines ladderLines;
+
+    public LadderGame(LadderLines ladderLines) {
+        this.ladderLines = ladderLines;
+    }
+
+    public static LadderGame of(int width, LadderHeight height, RandomStrategy strategy) {
+        return new LadderGame(LadderLines.of(width, height, strategy));
+    }
+
+    public int getFinalPosition(int startPosition) {
+        return ladderLines.getFinalPosition(startPosition);
+    }
+
+    public List<LadderLine> getLadderStructure() {
+        return ladderLines.getLines();
+    }
+}
diff --git a/src/main/java/domain/LadderGameResult.java b/src/main/java/domain/LadderGameResult.java
new file mode 100644
index 00000000..93d01124
--- /dev/null
+++ b/src/main/java/domain/LadderGameResult.java
@@ -0,0 +1,44 @@
+package domain;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class LadderGameResult {
+
+    private final Map<Player, ResultItem> results = new LinkedHashMap<>();
+
+    public LadderGameResult(Players players, ResultItems resultItems, LadderGame ladder) {
+        List<Player> playerList = players.extractPlayers();
+        List<ResultItem> resultList = resultItems.extractItems();
+
+        for (int i = 0; i < playerList.size(); i++) {
+            int finalPosition = ladder.getFinalPosition(i);
+
+            if (finalPosition >= resultItems.count()) {
+                throw new IllegalArgumentException("최종 위치가 결과의 범위를 벗어났습니다.");
+            }
+
+            results.put(playerList.get(i), resultList.get(finalPosition));
+        }
+    }
+
+    public ResultItem getSingleResultFor(Player player) {
+        if (!results.containsKey(player)) {
+            throw new IllegalArgumentException("존재하지 않는 플레이어입니다: " + player.getName());
+        }
+        return results.get(player);
+    }
+
+    public Map<Player, ResultItem> getAllResults() {
+        return results.entrySet()
+                .stream()
+                .collect(Collectors.toMap(
+                        Map.Entry::getKey,
+                        Map.Entry::getValue,
+                        (e1, e2) -> e1,
+                        LinkedHashMap::new
+                ));
+    }
+}
diff --git a/src/main/java/domain/LadderHeight.java b/src/main/java/domain/LadderHeight.java
new file mode 100644
index 00000000..d1b33fdc
--- /dev/null
+++ b/src/main/java/domain/LadderHeight.java
@@ -0,0 +1,12 @@
+package domain;
+
+public record LadderHeight(int value) {
+
+    private static final int MIN_HEIGHT_VALUE = 1;
+
+    public LadderHeight {
+        if (value < MIN_HEIGHT_VALUE) {
+            throw new IllegalArgumentException("사다리의 높이는 1 이상이어야 합니다.");
+        }
+    }
+}
diff --git a/src/main/java/domain/LadderLine.java b/src/main/java/domain/LadderLine.java
new file mode 100644
index 00000000..b4722b76
--- /dev/null
+++ b/src/main/java/domain/LadderLine.java
@@ -0,0 +1,35 @@
+package domain;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class LadderLine {
+
+    private final List<Point> points;
+
+    // 라인 겹침 로직 수정 필요
+    // 삼항 제거, else 사용 불가능, depth 체크
+    public LadderLine(int width, RandomStrategy strategy) {
+        this.points = List.copyOf(IntStream.range(0, width)
+                .mapToObj(i -> {
+                    if (i == width - 1) {
+                        return Point.NOT_CONNECTED;
+                    }
+                    return strategy.nextBoolean() ? Point.CONNECTED_RIGHT : Point.NOT_CONNECTED;
+                })
+                .toList());
+    }
+
+    public List<Point> getPoints() {
+        return List.copyOf(points);
+    }
+
+    public int move(int currentPosition) {
+        if (currentPosition < 0 || currentPosition >= points.size()) {
+            return currentPosition;
+        }
+
+        Point currentPoint = points.get(currentPosition);
+        return currentPoint.move(currentPosition, points.size());
+    }
+}
diff --git a/src/main/java/domain/LadderLines.java b/src/main/java/domain/LadderLines.java
new file mode 100644
index 00000000..aaea15d4
--- /dev/null
+++ b/src/main/java/domain/LadderLines.java
@@ -0,0 +1,35 @@
+package domain;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class LadderLines {
+
+    private final List<LadderLine> lines;
+
+    public LadderLines(List<LadderLine> lines) {
+        this.lines = List.copyOf(lines);
+    }
+
+    public static LadderLines of(int width, LadderHeight height, RandomStrategy strategy) {
+        return new LadderLines(
+                IntStream.range(0, height.value())
+                        .mapToObj(i -> new LadderLine(width, strategy))
+                        .toList()
+        );
+    }
+
+    public int getFinalPosition(int startPosition) {
+        int currentPosition = startPosition;
+
+        for (LadderLine line : lines) {
+            currentPosition = line.move(currentPosition);
+        }
+
+        return currentPosition;
+    }
+
+    public List<LadderLine> getLines() {
+        return List.copyOf(lines);
+    }
+}
diff --git a/src/main/java/domain/Player.java b/src/main/java/domain/Player.java
new file mode 100644
index 00000000..02c1e824
--- /dev/null
+++ b/src/main/java/domain/Player.java
@@ -0,0 +1,38 @@
+package domain;
+
+import java.util.Objects;
+
+public class Player {
+
+    private static final int MAX_NAME_LENGTH = 5;
+
+    private final String name;
+
+    public Player(String name) {
+        validateInput(name);
+        this.name = name;
+    }
+
+    private void validateInput(String name) {
+        if (name.isEmpty() || name.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException("참여할 사람의 이름은 1자 이상 " + MAX_NAME_LENGTH + "자 이하여야 합니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Player player = (Player) o;
+        return Objects.equals(name, player.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+}
diff --git a/src/main/java/domain/Players.java b/src/main/java/domain/Players.java
new file mode 100644
index 00000000..7bdd1c74
--- /dev/null
+++ b/src/main/java/domain/Players.java
@@ -0,0 +1,35 @@
+package domain;
+
+import java.util.List;
+
+public class Players {
+
+    private static final int MIN_PLAYERS_COUNT = 1;
+
+    private final List<Player> players;
+
+    public Players(List<Player> players) {
+        validateCount(players);
+        this.players = players;
+    }
+
+    private void validateCount(List<Player> players) {
+        if (players.isEmpty()) {
+            throw new IllegalArgumentException("참여 인원은 최소 " + MIN_PLAYERS_COUNT + "명 이상이어야 합니다.");
+        }
+    }
+
+    public int count() {
+        return players.size();
+    }
+
+    public List<Player> extractPlayers() {
+        return List.copyOf(players);
+    }
+
+    public List<String> extractNames() {
+        return players.stream()
+                .map(Player::getName)
+                .toList();
+    }
+}
diff --git a/src/main/java/domain/Point.java b/src/main/java/domain/Point.java
new file mode 100644
index 00000000..235ecb2c
--- /dev/null
+++ b/src/main/java/domain/Point.java
@@ -0,0 +1,25 @@
+package domain;
+
+import java.util.function.BiFunction;
+
+public enum Point {
+
+    // 왼쪽으로 연결됨
+    CONNECTED_LEFT(-1, (current, size) -> Math.max(0, current - 1)),
+    // 오른쪽으로 연결됨
+    CONNECTED_RIGHT(1, (current, size) -> Math.min(size - 1, current + 1)),
+    // 양쪽 아무 곳에도 연결되지 않음
+    NOT_CONNECTED(0, (current, size) -> current);
+
+    private final int offset;
+    private final BiFunction<Integer, Integer, Integer> moveLogic;
+
+    Point(int offset, BiFunction<Integer, Integer, Integer> moveLogic) {
+        this.offset = offset;
+        this.moveLogic = moveLogic;
+    }
+
+    public int move(int currentPosition, int size) {
+        return moveLogic.apply(currentPosition, size);
+    }
+}
diff --git a/src/main/java/domain/RandomGenerator.java b/src/main/java/domain/RandomGenerator.java
new file mode 100644
index 00000000..c1af500e
--- /dev/null
+++ b/src/main/java/domain/RandomGenerator.java
@@ -0,0 +1,21 @@
+package domain;
+
+import java.util.Random;
+
+public class RandomGenerator implements RandomStrategy {
+
+    private final Random random;
+
+    public RandomGenerator() {
+        this.random = new Random();
+    }
+
+    public RandomGenerator(long seed) {
+        this.random = new Random(seed);
+    }
+
+    @Override
+    public boolean nextBoolean() {
+        return random.nextBoolean();
+    }
+}
diff --git a/src/main/java/domain/RandomStrategy.java b/src/main/java/domain/RandomStrategy.java
new file mode 100644
index 00000000..a7f59209
--- /dev/null
+++ b/src/main/java/domain/RandomStrategy.java
@@ -0,0 +1,5 @@
+package domain;
+
+public interface RandomStrategy {
+    boolean nextBoolean();
+}
diff --git a/src/main/java/domain/ResultItem.java b/src/main/java/domain/ResultItem.java
new file mode 100644
index 00000000..a52e41a9
--- /dev/null
+++ b/src/main/java/domain/ResultItem.java
@@ -0,0 +1,21 @@
+package domain;
+
+public class ResultItem {
+
+    private final String item;
+
+    public ResultItem(String item) {
+        validate(item);
+        this.item = item;
+    }
+
+    private void validate(String item) {
+        if (item.isEmpty()) {
+            throw new IllegalArgumentException("실행 결과 값은 필수 입력 값입니다.");
+        }
+    }
+
+    public String getItem() {
+        return item;
+    }
+}
diff --git a/src/main/java/domain/ResultItems.java b/src/main/java/domain/ResultItems.java
new file mode 100644
index 00000000..aa4ce82a
--- /dev/null
+++ b/src/main/java/domain/ResultItems.java
@@ -0,0 +1,33 @@
+package domain;
+
+import java.util.List;
+
+public class ResultItems {
+
+    private final List<ResultItem> items;
+
+    public ResultItems(List<ResultItem> items, int expectedSize) {
+        validateCount(items, expectedSize);
+        this.items = items;
+    }
+
+    private void validateCount(List<ResultItem> items, int expectedSize) {
+        if (items.size() != expectedSize) {
+            throw new IllegalArgumentException("참여자의 수와 실행 결과 개수가 일치하지 않습니다.");
+        }
+    }
+
+    public int count() {
+        return items.size();
+    }
+
+    public List<ResultItem> extractItems() {
+        return List.copyOf(items);
+    }
+
+    public List<String> extractNames() {
+        return items.stream()
+                .map(ResultItem::getItem)
+                .toList();
+    }
+}
diff --git a/src/main/java/view/InputView.java b/src/main/java/view/InputView.java
new file mode 100644
index 00000000..d1b47db0
--- /dev/null
+++ b/src/main/java/view/InputView.java
@@ -0,0 +1,46 @@
+package view;
+
+import domain.LadderHeight;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+import java.util.stream.Collectors;
+
+public class InputView {
+
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public List<String> readPlayerNames() {
+        System.out.println("참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요): ");
+
+        String userInput = scanner.nextLine();
+        return Arrays.stream(userInput.split(","))
+                .map(String::trim)
+                .filter(name -> !name.isEmpty())
+                .collect(Collectors.toList());
+    }
+
+    public List<String> readResultItems() {
+        System.out.println();
+        System.out.println("실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요): ");
+
+        String userInput = scanner.nextLine();
+        return new ArrayList<>(Arrays.asList(userInput.split(",")));
+    }
+
+    public LadderHeight readHeight() {
+        System.out.println();
+        System.out.println("최대 사다리 높이는 몇 개인가요?");
+        int height = scanner.nextInt();
+        scanner.nextLine();
+        return new LadderHeight(height);
+    }
+
+    public String readResultRequest() {
+        System.out.println();
+        System.out.println("결과를 보고 싶은 사람은?");
+        return scanner.nextLine().trim();
+    }
+}
diff --git a/src/main/java/view/LadderPrinter.java b/src/main/java/view/LadderPrinter.java
new file mode 100644
index 00000000..e418df77
--- /dev/null
+++ b/src/main/java/view/LadderPrinter.java
@@ -0,0 +1,40 @@
+package view;
+
+import domain.LadderGame;
+import domain.LadderLine;
+import domain.Point;
+
+import java.util.List;
+
+public class LadderPrinter {
+
+    private static final String POINT = "|";
+    private static final String CONNECT_LINE = "-";
+    private static final String NO_CONNECT = " ";
+    private static final int CONNECTION_WIDTH = 5;
+
+    public static void printLadder(LadderGame ladderGame) {
+        List<LadderLine> ladderLines = ladderGame.getLadderStructure();
+        ladderLines.forEach(line -> {
+            StringBuilder lineBuilder = new StringBuilder();
+            lineBuilder.append(POINT);  // 첫 번째 포인트
+
+            List<Point> points = line.getPoints();
+            int lastIndex = points.size() - 1;
+
+            for (int i = 0; i < lastIndex; i++) {
+                appendConnection(lineBuilder, points.get(i));
+                lineBuilder.append(POINT);  // 다음 포인트
+            }
+            System.out.println(lineBuilder); // 한 줄 출력
+        });
+    }
+
+    private static void appendConnection(StringBuilder lineBuilder, Point point) {
+        if (point.move(0, CONNECTION_WIDTH) == 1) {
+            lineBuilder.append(CONNECT_LINE.repeat(CONNECTION_WIDTH));
+            return;
+        }
+        lineBuilder.append(NO_CONNECT.repeat(CONNECTION_WIDTH));
+    }
+}
diff --git a/src/main/java/view/OutputView.java b/src/main/java/view/OutputView.java
new file mode 100644
index 00000000..b39d188a
--- /dev/null
+++ b/src/main/java/view/OutputView.java
@@ -0,0 +1,44 @@
+package view;
+
+import domain.LadderGame;
+
+import java.util.List;
+import java.util.Map;
+
+public class OutputView {
+
+    private static final int SPACE_WIDTH = 6;
+    private final LadderPrinter ladderPrinter = new LadderPrinter();
+
+    public void printLadder(List<String> playerNames, LadderGame ladderGame, List<String> resultItems) {
+        System.out.println();
+        System.out.println("사다리 결과");
+        System.out.println();
+
+        printNames(playerNames);
+        ladderPrinter.printLadder(ladderGame);
+        printNames(resultItems);
+    }
+
+    private void printNames(List<String> names) {
+        for (String name : names) {
+            System.out.print(String.format("%-" + SPACE_WIDTH + "s", name));
+        }
+        System.out.println();
+    }
+
+    public void printSingleResult(String player, String resultItem) {
+        System.out.println();
+        System.out.println("실행 결과");
+        System.out.println(player + " : " + resultItem);
+    }
+
+    public void printAllResults(Map<String, String> ladderGameResult) {
+        System.out.println();
+        System.out.println("실행 결과");
+
+        ladderGameResult.forEach((player, result) ->
+                System.out.println(player + " : " + result)
+        );
+    }
+}
diff --git a/src/test/java/domain/LadderPrinterTest.java b/src/test/java/domain/LadderPrinterTest.java
new file mode 100644
index 00000000..64c7bb59
--- /dev/null
+++ b/src/test/java/domain/LadderPrinterTest.java
@@ -0,0 +1,30 @@
+package domain;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import view.LadderPrinter;
+
+public class LadderPrinterTest {
+
+    LadderGame ladderGame;
+
+    @BeforeEach
+    @DisplayName("사다리 게임 초기화")
+    void setUp() {
+        // 고정된 전략으로 테스트 (항상 오른쪽으로 연결됨)
+        RandomStrategy fixedStrategy = () -> true;
+        // 가로 5, 높이 3, 전략 주입
+        ladderGame = LadderGame.of(5, new LadderHeight(3), fixedStrategy);
+    }
+
+    @Test
+    @DisplayName("전체 사다리 출력 테스트")
+    void printLadderStructure() {
+        System.out.println("\n=== Ladder Structure ===");
+        LadderPrinter.printLadder(ladderGame);
+    }
+
+    // 출력 로직 오류
+    // 1. line 겹침
+}
diff --git a/src/test/java/domain/PlayerTest.java b/src/test/java/domain/PlayerTest.java
new file mode 100644
index 00000000..9a1969bb
--- /dev/null
+++ b/src/test/java/domain/PlayerTest.java
@@ -0,0 +1,43 @@
+package domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class PlayerTest {
+
+    @Test
+    @DisplayName("정상적인 이름이 주어졌을 때, 플레이어가 생성되어야 한다.")
+    void create() {
+        Player player = new Player("Tom");
+        assertEquals("Tom", player.getName());
+    }
+
+    @Test
+    @DisplayName("이름이 비어 있을 경우 예외가 발생해야 한다.")
+    void emptyNameThrowsException() {
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            new Player("");
+        });
+        assertEquals("참여할 사람의 이름은 1자 이상 5자 이하여야 합니다.", exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("이름이 5자를 초과하면 예외가 발생해야 한다.")
+    void longNameThrowsException() {
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            new Player("TommyLee");
+        });
+        assertEquals("참여할 사람의 이름은 1자 이상 5자 이하여야 합니다.", exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("다른 이름의 플레이어를 서로 다른 플레이어(객체)로 판단해야 한다.")
+    void playersWithDifferentNamesShouldNotBeEqual() {
+        Player player1 = new Player("Tom");
+        Player player2 = new Player("Jerry");
+
+        assertNotEquals(player1, player2);
+    }
+}
diff --git a/src/test/java/domain/PlayersTest.java b/src/test/java/domain/PlayersTest.java
new file mode 100644
index 00000000..d10ac2e6
--- /dev/null
+++ b/src/test/java/domain/PlayersTest.java
@@ -0,0 +1,54 @@
+package domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class PlayersTest {
+
+    @Test
+    @DisplayName("정상적인 플레이어 목록으로 생성된다.")
+    void create() {
+        List<Player> playerList = List.of(new Player("Tom"), new Player("Jerry"), new Player("Max"));
+        Players players = new Players(playerList);
+
+        assertEquals(3, players.count());
+    }
+
+    @Test
+    @DisplayName("플레이어 수가 0명일 경우 예외가 발생해야 한다.")
+    void emptyThrowsException() {
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            new Players(List.of());
+        });
+        assertEquals("참여 인원은 최소 1명 이상이어야 합니다.", exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("플레이어의 이름 목록을 정확히 추출한다.")
+    void extractNames() {
+        List<Player> playerList = List.of(new Player("Tom"), new Player("Jerry"), new Player("Max"));
+        Players players = new Players(playerList);
+
+        List<String> names = players.extractNames();
+        assertEquals(List.of("Tom", "Jerry", "Max"), names);
+    }
+
+    @Test
+    @DisplayName("플레이어 객체 목록을 정확히 반환한다.")
+    void extractPlayers() {
+        List<Player> playerList = List.of(new Player("Tom"), new Player("Jerry"), new Player("Max"));
+        Players players = new Players(playerList);
+
+        List<Player> extractedPlayers = players.extractPlayers();
+        assertEquals(3, extractedPlayers.size());
+        assertEquals(playerList, extractedPlayers);
+
+        assertThrows(UnsupportedOperationException.class, () -> {
+            extractedPlayers.add(new Player("John"));
+        });
+    }
+}
diff --git a/src/test/java/domain/ResultItemTest.java b/src/test/java/domain/ResultItemTest.java
new file mode 100644
index 00000000..d730ecd8
--- /dev/null
+++ b/src/test/java/domain/ResultItemTest.java
@@ -0,0 +1,25 @@
+package domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ResultItemTest {
+
+    @Test
+    @DisplayName("정상적인 값이 주어졌을 때, ResultItem이 생성되어야 한다.")
+    void create() {
+        ResultItem resultItem = new ResultItem("1등");
+        assertEquals("1등", resultItem.getItem());
+    }
+
+    @Test
+    @DisplayName("값이 비어 있을 경우 예외가 발생해야 한다.")
+    void emptyThrowsException() {
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            new ResultItem("");
+        });
+        assertEquals("실행 결과 값은 필수 입력 값입니다.", exception.getMessage());
+    }
+}
diff --git a/src/test/java/domain/ResultItemsTest.java b/src/test/java/domain/ResultItemsTest.java
new file mode 100644
index 00000000..37cd8876
--- /dev/null
+++ b/src/test/java/domain/ResultItemsTest.java
@@ -0,0 +1,56 @@
+package domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ResultItemsTest {
+
+    @Test
+    @DisplayName("정상적인 결과 목록으로 생성된다.")
+    void create() {
+        List<ResultItem> items = List.of(new ResultItem("1등"), new ResultItem("2등"), new ResultItem("꽝"));
+        ResultItems resultItems = new ResultItems(items, 3);
+
+        assertEquals(3, resultItems.count());
+    }
+
+    @Test
+    @DisplayName("결과 개수가 예상 개수와 일치하지 않으면 예외가 발생해야 한다.")
+    void sizeMismatchThrowsException() {
+        List<ResultItem> items = List.of(new ResultItem("1등"), new ResultItem("꽝"));
+
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            new ResultItems(items, 3);
+        });
+        assertEquals("참여자의 수와 실행 결과 개수가 일치하지 않습니다.", exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("결과 목록의 값을 정확히 추출한다.")
+    void extractNames() {
+        List<ResultItem> items = List.of(new ResultItem("1등"), new ResultItem("2등"), new ResultItem("꽝"));
+        ResultItems resultItems = new ResultItems(items, 3);
+
+        List<String> names = resultItems.extractNames();
+        assertEquals(List.of("1등", "2등", "꽝"), names);
+    }
+
+    @Test
+    @DisplayName("결과 객체 목록을 정확히 반환한다.")
+    void extractItems() {
+        List<ResultItem> items = List.of(new ResultItem("1등"), new ResultItem("2등"), new ResultItem("꽝"));
+        ResultItems resultItems = new ResultItems(items, 3);
+
+        List<ResultItem> extractedItems = resultItems.extractItems();
+        assertEquals(3, extractedItems.size());
+        assertEquals(items, extractedItems);
+
+        assertThrows(UnsupportedOperationException.class, () -> {
+            extractedItems.add(new ResultItem("4등"));
+        });
+    }
+}