diff --git a/src/main/java/LadderApplication.java b/src/main/java/LadderApplication.java
new file mode 100644
index 00000000..ed6df3e8
--- /dev/null
+++ b/src/main/java/LadderApplication.java
@@ -0,0 +1,8 @@
+import controller.LadderController;
+
+public class LadderApplication {
+    public static void main(String[] args) {
+        LadderController ladderController = new LadderController();
+        ladderController.run();
+    }
+}
diff --git a/src/main/java/controller/LadderController.java b/src/main/java/controller/LadderController.java
new file mode 100644
index 00000000..d485a053
--- /dev/null
+++ b/src/main/java/controller/LadderController.java
@@ -0,0 +1,65 @@
+package controller;
+
+import domain.Ladder;
+import domain.Name;
+import domain.Player;
+import domain.Players;
+import domain.Result;
+import domain.Results;
+import view.InputView;
+import view.OutputView;
+
+public class LadderController {
+
+    private final Players players;
+    private final Results results;
+
+    public LadderController() {
+        players = Players.of(InputView.inputPlayerNames());
+        results = Results.of(InputView.inputResults());
+    }
+
+    public void run() {
+        Ladder ladder = createLadder();
+        OutputView.printLadderInfo(players, results, ladder);
+        players.moveDown(ladder);
+        runResultQueryLoop();
+    }
+
+    private Ladder createLadder() {
+        int ladderWidth = players.getPlayers().size();
+        int ladderHeight = InputView.inputHeight();
+        return new Ladder(ladderWidth, ladderHeight);
+    }
+
+    private void runResultQueryLoop() {
+        while (checkResultLoop());
+    }
+
+    private Boolean checkResultLoop() {
+        String name = InputView.inputPlayerNameToCheckResult();
+        if (name.isEmpty()) {
+            return false;
+        }
+        if (name.trim().equals("all")) {
+            printAllResults(players, results);
+            return true;
+        }
+        printSingleResult(name, players, results);
+        return true;
+    }
+
+    private void printAllResults(Players players, Results results) {
+        for (Player player : players.getPlayers()) {
+            Result result = results.findByPosition(player.getPosition());
+            OutputView.printResult(player, result);
+        }
+    }
+
+    private void printSingleResult(String name, Players players, Results results) {
+        Player player = players.findByName(new Name(name));
+        Result result = results.findByPosition(player.getPosition());
+        OutputView.printResult(player, result);
+    }
+
+}
diff --git a/src/main/java/domain/Ladder.java b/src/main/java/domain/Ladder.java
new file mode 100644
index 00000000..6a088b3c
--- /dev/null
+++ b/src/main/java/domain/Ladder.java
@@ -0,0 +1,30 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Ladder {
+
+    private final List<Line> lines;
+
+    public Ladder(int width, int height) {
+        validate(width, height);
+        lines = new ArrayList<>();
+        for (int i = 0; i < height; i++) {
+            lines.add(Line.from(width - 1));
+        }
+    }
+
+    private void validate(int width, int height) {
+        if (width <= 1) {
+            throw new IllegalArgumentException("사다리의 너비는 1보다 커야 합니다.");
+        }
+        if (height <= 0) {
+            throw new IllegalArgumentException("사다리의 높이는 0보다 커야 합니다.");
+        }
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+}
diff --git a/src/main/java/domain/Line.java b/src/main/java/domain/Line.java
new file mode 100644
index 00000000..94b0096a
--- /dev/null
+++ b/src/main/java/domain/Line.java
@@ -0,0 +1,39 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Line {
+
+    private final List<Point> points;
+
+    private Line(List<Point> points) {
+        this.points =  points;
+    }
+
+    public static Line from(int width) {
+        return new Line(createRandomLine(width));
+    }
+
+    private static List<Point> createRandomLine(int width) {
+        List<Point> points = new ArrayList<>();
+        points.add(new Point(PointState.randomState()));
+        for (int i = 1; i < width; i++) {
+            Point lastState = points.get(points.size() - 1);
+            PointState newState = generateNextState(lastState);
+            points.add(new Point(newState));
+        }
+        return points;
+    }
+
+    private static PointState generateNextState(Point lastPoint) {
+        if (lastPoint.isMovable()) {
+            return PointState.NOT_MOVABLE;
+        }
+        return PointState.randomState();
+    }
+
+    public List<Point> getPoints() {
+        return points;
+    }
+}
diff --git a/src/main/java/domain/Name.java b/src/main/java/domain/Name.java
new file mode 100644
index 00000000..3b343a28
--- /dev/null
+++ b/src/main/java/domain/Name.java
@@ -0,0 +1,42 @@
+package domain;
+
+import java.util.Objects;
+
+public class Name {
+    private final String name;
+
+
+    public Name(String name) {
+        validate(name);
+        this.name = name;
+    }
+
+    private void validate(String name) {
+        if (name == null || name.trim().isEmpty()) {
+            throw new IllegalArgumentException("이름은 null이나 빈 문자열일 수 없습니다.");
+        }
+        if (name.length() > 5) {
+            throw new IllegalArgumentException("이름은 5자 이하이어야 합니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) {
+            return true;
+        }
+        if (object instanceof Name other) {
+            return Objects.equals(name, other.name);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+}
diff --git a/src/main/java/domain/Player.java b/src/main/java/domain/Player.java
new file mode 100644
index 00000000..19e4e06d
--- /dev/null
+++ b/src/main/java/domain/Player.java
@@ -0,0 +1,61 @@
+package domain;
+
+import java.util.List;
+
+public class Player {
+    private final Name name;
+    private final Position position;
+
+    public Player(Name name, Position position) {
+        this.position = position;
+        this.name = name;
+    }
+
+    public void downLadder(Ladder ladder) {
+        List<Line> lines = ladder.getLines();
+        for (Line line : lines) {
+            checkAndMove(line);
+        }
+    }
+
+    public void checkAndMove(Line line) {
+        List<Point> points = line.getPoints();
+        if (checkLeft(points)) {
+            position.moveLeft();
+            return;
+        }
+        if (checkRight(points)) {
+            position.moveRight();
+        }
+    }
+
+    public boolean checkLeft(List<Point> points) {
+        Point leftPoint = null;
+        if (position.getPosition() > 0) {
+            leftPoint = points.get(position.getPosition() - 1);
+        }
+
+        return leftPoint != null && leftPoint.isMovable();
+    }
+
+    public boolean checkRight(List<Point> points) {
+        Point rightPoint = null;
+        if (position.getPosition() < points.size()) {
+            rightPoint = points.get(position.getPosition());
+        }
+
+        return rightPoint != null && rightPoint.isMovable();
+    }
+
+    public boolean hasName(Name other) {
+        return name.equals(other);
+    }
+
+    public Position getPosition() {
+        return position;
+    }
+
+    public Name getName() {
+        return name;
+    }
+}
diff --git a/src/main/java/domain/Players.java b/src/main/java/domain/Players.java
new file mode 100644
index 00000000..2f4bed18
--- /dev/null
+++ b/src/main/java/domain/Players.java
@@ -0,0 +1,48 @@
+package domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class Players {
+    private final List<Player> players;
+
+    private Players(List<Player> players) {
+        this.players = players;
+    }
+
+    public static Players of(List<String> names) {
+        validate(names);
+        List<Player> players = names.stream()
+                .map(name -> new Player(new Name(name), new Position(names.indexOf(name))))
+                .collect(Collectors.toList());
+        return new Players(players);
+    }
+
+    private static void validate(List<String> names) {
+        Set<String> nameSet = new HashSet<>();
+        names.forEach(name -> checkDuplicate(nameSet, name));
+    }
+
+    private static void checkDuplicate(Set<String> nameSet, String name) {
+        if (!nameSet.add(name)) {
+            throw new IllegalArgumentException("중복된 이름이 있습니다: " + name);
+        }
+    }
+
+    public void moveDown(Ladder ladder) {
+        players.forEach(player -> player.downLadder(ladder));
+    }
+
+    public Player findByName(Name name) {
+        return players.stream()
+                .filter(player -> player.hasName(name))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 이름입니다: " + name.getName()));
+    }
+
+    public List<Player> getPlayers() {
+        return players;
+    }
+}
diff --git a/src/main/java/domain/Point.java b/src/main/java/domain/Point.java
new file mode 100644
index 00000000..28dc4187
--- /dev/null
+++ b/src/main/java/domain/Point.java
@@ -0,0 +1,22 @@
+package domain;
+
+public class Point {
+    private PointState state;
+
+    public Point(PointState state) {
+        this.state = state;
+    }
+
+    public boolean isMovable() {
+        return state == PointState.MOVABLE;
+    }
+
+    public void setMovable(boolean movable) {
+        if (movable) {
+            state = PointState.MOVABLE;
+        }
+        if (!movable) {
+            state = PointState.NOT_MOVABLE;
+        }
+    }
+}
diff --git a/src/main/java/domain/PointState.java b/src/main/java/domain/PointState.java
new file mode 100644
index 00000000..69104491
--- /dev/null
+++ b/src/main/java/domain/PointState.java
@@ -0,0 +1,26 @@
+package domain;
+
+import java.util.Random;
+
+public enum PointState {
+    MOVABLE("-----"),
+    NOT_MOVABLE("     ");
+
+    private final String display;
+    private static final Random random = new Random();
+
+    PointState(String display) {
+        this.display = display;
+    }
+
+    public String getDisplay() {
+        return display;
+    }
+
+    public static PointState randomState() {
+        if (random.nextBoolean()){
+            return MOVABLE;
+        }
+        return NOT_MOVABLE;
+    }
+}
diff --git a/src/main/java/domain/Position.java b/src/main/java/domain/Position.java
new file mode 100644
index 00000000..9e11a79f
--- /dev/null
+++ b/src/main/java/domain/Position.java
@@ -0,0 +1,46 @@
+package domain;
+
+import java.util.Objects;
+
+public class Position {
+    private int position;
+
+    public Position(int position) {
+        validate(position);
+        this.position = position;
+    }
+
+    private void validate(int position) {
+        if (position < 0) {
+            throw new IllegalArgumentException("Position은 음수일 수 없습니다.");
+        }
+    }
+
+    public void moveLeft() {
+        position--;
+    }
+
+    public void moveRight() {
+        position++;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) {
+            return true;
+        }
+        if (!(object instanceof Position other)) {
+            return false;
+        }
+        return position == other.position;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(position);
+    }
+}
diff --git a/src/main/java/domain/Result.java b/src/main/java/domain/Result.java
new file mode 100644
index 00000000..f46580a2
--- /dev/null
+++ b/src/main/java/domain/Result.java
@@ -0,0 +1,23 @@
+package domain;
+
+public class Result {
+    private final String result;
+
+    public Result(String result) {
+        validate(result);
+        this.result = result;
+    }
+
+    public String getResult() {
+        return result;
+    }
+
+    private void validate(String result) {
+        if (result == null || result.trim().isEmpty()) {
+            throw new IllegalArgumentException("결과는 빈 문자열일 수 없습니다.");
+        }
+        if (result.length() > 5) {
+            throw new IllegalArgumentException("결과는 5자 이하로 제한됩니다.");
+        }
+    }
+}
diff --git a/src/main/java/domain/Results.java b/src/main/java/domain/Results.java
new file mode 100644
index 00000000..41c44a41
--- /dev/null
+++ b/src/main/java/domain/Results.java
@@ -0,0 +1,27 @@
+package domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Results {
+    private final List<Result> results;
+
+    private Results(List<Result> results) {
+        this.results = results;
+    }
+
+    public static Results of(List<String> results) {
+        List<Result> resultList = results.stream()
+                .map(Result::new)
+                .collect(Collectors.toList());
+        return new Results(resultList);
+    }
+
+    public Result findByPosition(Position position) {
+        return results.get(position.getPosition());
+    }
+
+    public List<Result> 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..82bc486f
--- /dev/null
+++ b/src/main/java/view/InputView.java
@@ -0,0 +1,34 @@
+package view;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class InputView {
+
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public static List<String> inputPlayerNames() {
+        System.out.println("참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)");
+        String[] names = scanner.nextLine().split(",");
+        return Arrays.stream(names).toList();
+    }
+
+    public static List<String> inputResults() {
+        System.out.println("실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)");
+        String[] results = scanner.nextLine().split(",");
+        return Arrays.stream(results).toList();
+    }
+
+    public static int inputHeight() {
+        System.out.println("사다리의 높이는 몇 개인가요?");
+        int height = scanner.nextInt();
+        scanner.nextLine();
+        return height;
+    }
+
+    public static String inputPlayerNameToCheckResult() {
+        System.out.println("결과를 보고 싶은 사람은?(공백인 상태로 엔터를 입력하면 종료됩니다)");
+        return scanner.nextLine();
+    }
+}
diff --git a/src/main/java/view/OutputView.java b/src/main/java/view/OutputView.java
new file mode 100644
index 00000000..09b86f31
--- /dev/null
+++ b/src/main/java/view/OutputView.java
@@ -0,0 +1,65 @@
+package view;
+
+import domain.Ladder;
+import domain.Line;
+import domain.Player;
+import domain.Players;
+import domain.Point;
+import domain.Result;
+import domain.Results;
+import java.util.List;
+
+public class OutputView {
+
+    private static final String LADDER_POINT = "-----";
+    private static final String NO_LADDER_POINT = "     ";
+
+    public static void printLadderInfo(Players players, Results results, Ladder ladder) {
+        System.out.println("사다리 결과");
+        printPlayers(players.getPlayers());
+        printLadder(ladder);
+        printResults(results.getResults());
+    }
+
+    public static void printLadder(Ladder ladder) {
+        List<Line> lines = ladder.getLines();
+        for (Line line : lines) {
+            printLine(line);
+        }
+    }
+
+    public static void printPlayers(List<Player> players) {
+        for (Player player : players) {
+            System.out.printf("%-5s ", player.getName().getName());
+        }
+        System.out.println();
+    }
+
+    public static void printResults(List<Result> results) {
+        for (Result result : results) {
+            System.out.printf("%-5s ", result.getResult());
+        }
+        System.out.println();
+    }
+
+    private static void printLine(Line line) {
+        List<Point> points = line.getPoints();
+        System.out.print("  ");
+        for (Point point : points) {
+            System.out.print("|");
+            System.out.print(getPointFormat(point.isMovable()));
+        }
+        System.out.println("|");
+    }
+
+    public static void printResult(Player player, Result result) {
+        System.out.println(player.getName().getName() + " : " + result.getResult());
+    }
+
+    private static String getPointFormat(Boolean point) {
+        if (point) {
+            return LADDER_POINT;
+        }
+        return NO_LADDER_POINT;
+    }
+}
diff --git a/src/test/java/domain/LadderTest.java b/src/test/java/domain/LadderTest.java
new file mode 100644
index 00000000..598cd62c
--- /dev/null
+++ b/src/test/java/domain/LadderTest.java
@@ -0,0 +1,39 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class LadderTest {
+
+    @Test
+    void 사다리_너비가_1이하_일경우_예외_발생() {
+        int width = 1;
+        int height = 5;
+
+        assertThatThrownBy(() -> new Ladder(width, height))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("사다리의 너비는 1보다 커야 합니다.");
+    }
+
+    @Test
+    void 사다리_높이가_0이하_일경우_예외_발생() {
+        int width = 5;
+        int height = 0;
+
+        assertThatThrownBy(() -> new Ladder(width, height))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("사다리의 높이는 0보다 커야 합니다.");
+    }
+
+    @Test
+    void 유효한_너비와_높이로_사다리_생성() {
+        int width = 5;
+        int height = 3;
+
+        Ladder ladder = new Ladder(width, height);
+
+        assertThat(ladder.getLines()).hasSize(height);
+    }
+}
diff --git a/src/test/java/domain/LineTest.java b/src/test/java/domain/LineTest.java
new file mode 100644
index 00000000..99a23ce3
--- /dev/null
+++ b/src/test/java/domain/LineTest.java
@@ -0,0 +1,41 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LineTest {
+
+    @Test
+    void 라인은_지정된_길이만큼_Point_리스트를_생성한다() {
+        int width = 5;
+
+        Line line = Line.from(width);
+        List<Point> points = line.getPoints();
+
+        assertThat(points).hasSize(width);
+    }
+
+    @Test
+    void 라인의_인접한_Point는_동시에_MOVABLE일_수_없다() {
+        List<Point> points = Line.from(100).getPoints();
+
+        for (int i = 1; i < points.size(); i++) {
+            assertThat(points.get(i - 1).isMovable() && points.get(i).isMovable()).isFalse();
+        }
+    }
+
+    @Test
+    void 점의_상태는_Movable_또는_NotMovable_만_있어야한다() {
+        int width = 5;
+
+        Line line = Line.from(width);
+
+        List<Point> points = line.getPoints();
+        points.forEach(point -> {
+            assertThat(point.isMovable()).isIn(true, false);
+        });
+    }
+}
diff --git a/src/test/java/domain/NameTest.java b/src/test/java/domain/NameTest.java
new file mode 100644
index 00000000..b8d82962
--- /dev/null
+++ b/src/test/java/domain/NameTest.java
@@ -0,0 +1,45 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class NameTest {
+
+    @Test
+    void 이름이_정상적으로_설정된다() {
+        String validName = "Alice";
+
+        Name name = new Name(validName);
+
+        assertEquals(validName, name.getName());
+    }
+
+    @Test
+    void 이름이_빈_문자열_일때_예외가_발생한다() {
+        String invalidName = "";
+
+        assertThatThrownBy(() -> new Name(invalidName))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("이름은 null이나 빈 문자열일 수 없습니다.");
+    }
+
+    @Test
+    void 이름이_null일_때_예외가_발생한다() {
+        String invalidName = null;
+
+        assertThatThrownBy(() -> new Name(invalidName))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("이름은 null이나 빈 문자열일 수 없습니다.");
+    }
+
+    @Test
+    void 이름이_5자_초과일_때_예외가_발생한다() {
+        String invalidName = "ABCDEFG";
+
+        assertThatThrownBy(() -> new Name(invalidName))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("이름은 5자 이하이어야 합니다.");
+    }
+}
diff --git a/src/test/java/domain/PlayerTest.java b/src/test/java/domain/PlayerTest.java
new file mode 100644
index 00000000..5146e000
--- /dev/null
+++ b/src/test/java/domain/PlayerTest.java
@@ -0,0 +1,52 @@
+package domain;
+
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PlayerTest {
+
+    private Ladder ladder;
+    private Player player;
+
+    @BeforeEach
+    void setUp() {
+        Name playerName = new Name("Test");
+        Position playerPosition = new Position(1);
+        player = new Player(playerName, playerPosition);
+        ladder = new Ladder(3, 1);
+    }
+
+    @Test
+    void 플레이어가_왼쪽_이동_가능하면_위치가_변한다() {
+        ladder.getLines().get(0).getPoints().get(0).setMovable(true);
+        ladder.getLines().get(0).getPoints().get(1).setMovable(false);
+
+        player.downLadder(ladder);
+
+        assertThat(player.getPosition().getPosition()).isEqualTo(0);
+    }
+
+    @Test
+    void 플레이어가_오른쪽_이동_가능하면_위치가_변한다() {
+        ladder.getLines().get(0).getPoints().get(0).setMovable(false);
+        ladder.getLines().get(0).getPoints().get(1).setMovable(true);
+
+        player.downLadder(ladder);
+
+        assertThat(player.getPosition().getPosition()).isEqualTo(2);
+    }
+
+    @Test
+    void 플레이어가_이동_불가능하면_위치가_변하지_않는다() {
+        ladder.getLines().get(0).getPoints().get(0).setMovable(false);
+        ladder.getLines().get(0).getPoints().get(1).setMovable(false);
+
+        player.downLadder(ladder);
+
+        assertThat(player.getPosition().getPosition()).isEqualTo(1);
+    }
+
+}
diff --git a/src/test/java/domain/PlayersTest.java b/src/test/java/domain/PlayersTest.java
new file mode 100644
index 00000000..a0a391a1
--- /dev/null
+++ b/src/test/java/domain/PlayersTest.java
@@ -0,0 +1,48 @@
+package domain;
+
+
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class PlayersTest {
+
+    private Players players;
+
+    @BeforeEach
+    void setUp() {
+        players = Players.of(List.of("Alice", "Bob", "John"));
+    }
+
+    @Test
+    void 플레이어_리스트가_정상적으로_생성된다() {
+        int size = players.getPlayers().size();
+        assertThat(size).isEqualTo(3);
+    }
+
+    @Test
+    void 플레이어_이름으로_찾기() {
+        Name name = new Name("Bob");
+        Player foundPlayer = players.findByName(name);
+        assertThat(foundPlayer.getName().getName()).isEqualTo("Bob");
+    }
+
+    @Test
+    void 존재하지_않는_이름으로_플레이어_찾기() {
+        Name name = new Name("Dave");
+
+        assertThatThrownBy(() -> players.findByName(name))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("존재하지 않는 이름입니다: Dave");
+    }
+
+    @Test
+    void 중복된_이름으로_플레이어_생성시_예외가_발생한다() {
+        assertThatThrownBy(() -> Players.of(List.of("Alice", "Alice")))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("중복된 이름이 있습니다: Alice");
+    }
+}
diff --git a/src/test/java/domain/PointStateTest.java b/src/test/java/domain/PointStateTest.java
new file mode 100644
index 00000000..c9c39ffc
--- /dev/null
+++ b/src/test/java/domain/PointStateTest.java
@@ -0,0 +1,33 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PointStateTest {
+
+    @Test
+    void MOVABLE_상태의_getDisplay_는_하이픈_5개여야_한다() {
+        PointState movableState = PointState.MOVABLE;
+
+        String result = movableState.getDisplay();
+
+        assertThat(result).isEqualTo("-----");
+    }
+
+    @Test
+    void NOT_MOVABLE_상태의_getDisplay_는_공백_5개여야_한다() {
+        PointState notMovableState = PointState.NOT_MOVABLE;
+
+        String result = notMovableState.getDisplay();
+
+        assertThat(result).isEqualTo("     ");
+    }
+
+    @Test
+    void randomState_메서드는_MOVABLE_또는_NOT_MOVABLE_을_반환해야_한다() {
+        PointState randomState = PointState.randomState();
+
+        assertThat(randomState).isIn(PointState.MOVABLE, PointState.NOT_MOVABLE);
+    }
+}
diff --git a/src/test/java/domain/PointTest.java b/src/test/java/domain/PointTest.java
new file mode 100644
index 00000000..1219fca3
--- /dev/null
+++ b/src/test/java/domain/PointTest.java
@@ -0,0 +1,26 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PointTest {
+
+    @Test
+    void MOVABLE_상태일_때_isMovable_반환값이_true여야_한다() {
+        Point movablePoint = new Point(PointState.MOVABLE);
+
+        boolean result = movablePoint.isMovable();
+
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    void NOT_MOVABLE_상태일_때_isMovable_반환값이_false여야_한다() {
+        Point notMovablePoint = new Point(PointState.NOT_MOVABLE);
+
+        boolean result = notMovablePoint.isMovable();
+
+        assertThat(result).isFalse();
+    }
+}
diff --git a/src/test/java/domain/PositionTest.java b/src/test/java/domain/PositionTest.java
new file mode 100644
index 00000000..42f7dd23
--- /dev/null
+++ b/src/test/java/domain/PositionTest.java
@@ -0,0 +1,59 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class PositionTest {
+
+    @Test
+    void Position_생성자는_음수_값에_대해_예외를_던져야_한다() {
+        assertThatThrownBy(() -> new Position(-1))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("Position은 음수일 수 없습니다.");
+    }
+
+    @Test
+    void Position_생성자는_0이상_값을_허용해야_한다() {
+        Position position = new Position(0);
+
+        assertThat(position.getPosition()).isEqualTo(0);
+    }
+
+    @Test
+    void moveLeft_메서드는_위치를_하나씩_왼쪽으로_이동시킨다() {
+        Position position = new Position(3);
+
+        position.moveLeft();
+
+        assertThat(position.getPosition()).isEqualTo(2);
+    }
+
+    @Test
+    void moveRight_메서드는_위치를_하나씩_오른쪽으로_이동시킨다() {
+        Position position = new Position(3);
+
+        position.moveRight();
+
+        assertThat(position.getPosition()).isEqualTo(4);
+    }
+
+    @Test
+    void equals_메서드는_같은_위치_값을_비교한다() {
+        Position position1 = new Position(3);
+        Position position2 = new Position(3);
+        Position position3 = new Position(4);
+
+        assertThat(position1).isEqualTo(position2);
+        assertThat(position1).isNotEqualTo(position3);
+    }
+
+    @Test
+    void hashCode_메서드는_같은_위치값에_대해_같은_해시코드를_반환해야_한다() {
+        Position position1 = new Position(3);
+        Position position2 = new Position(3);
+
+        assertThat(position1.hashCode()).isEqualTo(position2.hashCode());
+    }
+}
diff --git a/src/test/java/domain/ResultTest.java b/src/test/java/domain/ResultTest.java
new file mode 100644
index 00000000..9c514cc9
--- /dev/null
+++ b/src/test/java/domain/ResultTest.java
@@ -0,0 +1,39 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class ResultTest {
+
+    @Test
+    void 결과는_정상적으로_생성되어야_한다() {
+        String value = "성공";
+
+        Result result = new Result(value);
+
+        assertThat(result.getResult()).isEqualTo(value);
+    }
+
+    @Test
+    void 결과가_null이면_예외를_던져야_한다() {
+        assertThatThrownBy(() -> new Result(null))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("결과는 빈 문자열일 수 없습니다.");
+    }
+
+    @Test
+    void 결과가_빈_문자열이면_예외를_던져야_한다() {
+        assertThatThrownBy(() -> new Result("   "))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("결과는 빈 문자열일 수 없습니다.");
+    }
+
+    @Test
+    void 결과가_6자_이상이면_예외를_던져야_한다() {
+        assertThatThrownBy(() -> new Result("abcdef"))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("결과는 5자 이하로 제한됩니다.");
+    }
+}
diff --git a/src/test/java/domain/ResultsTest.java b/src/test/java/domain/ResultsTest.java
new file mode 100644
index 00000000..ad01de67
--- /dev/null
+++ b/src/test/java/domain/ResultsTest.java
@@ -0,0 +1,43 @@
+package domain;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class ResultsTest {
+
+    @Test
+    void 문자열_리스트로부터_Results_객체를_생성할_수_있다() {
+        List<String> resultStrings = Arrays.asList("1등", "2등", "3등");
+
+        Results results = Results.of(resultStrings);
+
+        List<Result> resultList = results.getResults();
+        assertThat(resultList).hasSize(3);
+        assertThat(resultList).extracting(Result::getResult)
+                .containsExactly("1등", "2등", "3등");
+    }
+
+    @Test
+    void position에_해당하는_결과를_찾을_수_있다() {
+        Results results = Results.of(Arrays.asList("2000", "꽝", "3000"));
+        Position position = new Position(1);
+
+        Result result = results.findByPosition(position);
+
+        assertThat(result.getResult()).isEqualTo("꽝");
+    }
+
+    @Test
+    void position이_결과_리스트_범위를_벗어나면_예외를_던진다() {
+        Results results = Results.of(Arrays.asList("a", "b"));
+        Position invalid = new Position(5);
+
+        assertThatThrownBy(() -> results.findByPosition(invalid))
+                .isInstanceOf(IndexOutOfBoundsException.class);
+    }
+}