diff --git a/.gitignore b/.gitignore
index 6c01878138..5319a390a6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,3 +30,5 @@ out/
 
 ### VS Code ###
 .vscode/
+
+REFACTORING.md
diff --git a/README.md b/README.md
index 9775dda0ae..3362d80923 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,172 @@
 # java-janggi
 
-장기 미션 저장소
+## 📋 목차
+
+- [개요](#-개요)
+- [구현 기능 목록](#-구현-기능-목록)
+- [입출력 요구 사항](#입출력-요구-사항)
+- [커밋 컨벤션](#커밋-컨벤션)
+
+---
+
+## 1️⃣ 개요
+
+### 기능 흐름
+
+```
+[게임 시작]
+     │
+     ▼
+[상차림 입력 - ReadyState]
+  한(HAN) 상차림 선택 (1~4)
+     │ 예외 → 재입력
+     ▼
+  초(CHO) 상차림 선택 (1~4)
+     │ 예외 → 재입력
+     ▼
+[보드 초기화]
+  입력된 상차림 기준으로 기물 배치
+     │
+     ▼
+[게임 진행 - PlayingState] ◄────────────────┐
+  현재 턴 출력 + 보드 출력                     │
+     │                                    │
+     ▼                                    │
+  착수 명령어 입력 ({출발좌표} {도착좌표})        │
+     │ 예외 → 재입력 (현재 턴 유지)            │
+     ▼                                    │
+  이동 유효성 검증                            │
+    ├─ 출발 좌표에 기물 없음 → 예외             │
+    ├─ 출발 좌표가 상대 기물 → 예외             │
+    ├─ 도착 좌표에 아군 기물 → 예외             │
+    └─ 기물 이동 규칙 위반 → 예외              │
+     │ 성공                                │
+     ▼                                    │
+  기물 이동 (도착 좌표에 상대 기물 있으면 제거)     │
+     │                                    │
+     ▼                                    │
+  턴 교체 (한 ↔ 초) ─────────────────────────┘
+```
+
+## 2️⃣ 구현 기능 목록
+
+### ✅ 1차 구현 기능 목록
+
+#### 1.1단계: 보드 초기화
+
+- [x] **1. [출력] 상차림 예시를 출력한다.**
+- [x] **2. [입력] 상차림을 입력받는다.**
+    - [x] [입력] 한의 상차림을 입력받는다.
+        - [x] [예외 처리] 빈 입력일 경우 `IllegalArgumentException` 을 발생시키고, 재입력을 받는다.
+        - [x] [예외 처리] 1~4 외의 문자를 입력한 경우 `IllegalArgumentException` 을 발생시키고, 재입력을 받는다.
+    - [x] [입력] 초의 상차림을 입력받는다.
+        - [x] [예외 처리] 빈 입력일 경우 `IllegalArgumentException` 을 발생시키고, 재입력을 받는다.
+        - [x] [예외 처리] 1~4 외의 문자를 입력한 경우 `IllegalArgumentException` 을 발생시키고, 재입력을 받는다.
+- [x] **3. [중간 과정] 입력받은 상차림을 기준으로 기물을 배치한다.**
+- [x] **4. [출력] 현재 보드의 기물 배치를 출력한다.**
+
+#### 1.2단계: 기물 이동
+
+- [x] **5. [출력] 착수 명령어 형식과 현재 어느 팀의 턴인지를 출력한다.**
+- [x] **6. [입력] 현재 턴의 진행자에게 착수 명령어를 입력받는다. (ex. '{출발좌표} {도착좌표}' 'A0 B1')**
+    - [x] [예외 처리] 빈 입력일 경우 `IllegalArgumentException` 을 발생시키고, 재입력을 받는다.
+    - [x] [예외 처리] 입력받은 값이 지정 형식인 '{출발좌표} {도착좌표}'가 아닐 경우 ` IllegalArgumentException` 을 발생시키고, 재입력을 받는다.
+    - [x] [예외 처리] 입력받은 column 값이 A~I 범위의 값이 아닌 경우 `IllegalArgumentException` 을 발생시키고, 재입력을 받는다.
+    - [x] [예외 처리] 입력받은 row 값이 0~9 범위의 값이 아닌 경우 `IllegalArgumentException` 을 발생시키고, 재입력을 받는다.
+- [x] **7. [중간 과정] 사용자가 명령한 착수를 수행한다.**
+    - [x] [예외 처리] 아래의 경우 왜 이동이 불가능한지 출력하고, 해당 플레이어의 턴으로 처음부터 재입력을 받는다.
+        - [x] [중간 과정] 출발 좌표에 기물이 없는 경우
+        - [x] [중간 과정] 출발 좌표에 상대 기물이 있는 경우
+        - [x] [중간 과정] 각 기물 고유의 이동 규칙에 따라 이동이 불가능한 경우
+        - [x] [중간 과정] 도착 좌표에 아군 기물이 있을 경우
+    - [x] [중간 과정] 도착 좌표에 상대 기물이 있으면 없앤다.
+    - [x] [중간 과정] 출발 좌표에 있던 기물을 도착 좌표로 옮긴다.
+    - [x] [중간 과정] 턴을 넘긴다.
+
+## 3️⃣ 입출력 요구 사항
+
+### 실행 결과 예시
+
+```
+[한(HAN) 진영] 배치를 선택하세요.
+1. 마-상-마-상 (Horse-Elephant-Horse-Elephant)
+2. 마-상-상-마 (Horse-Elephant-Elephant-Horse)
+3. 상-마-마-상 (Elephant-Horse-Horse-Elephant)
+4. 상-마-상-마 (Elephant-Horse-Elephant-Horse)
+> 1
+
+[초(CHO) 진영] 배치를 선택하세요.
+1. 마-상-마-상 (Horse-Elephant-Horse-Elephant)
+2. 마-상-상-마 (Horse-Elephant-Elephant-Horse)
+3. 상-마-마-상 (Elephant-Horse-Horse-Elephant)
+4. 상-마-상-마 (Elephant-Horse-Elephant-Horse)
+> 2
+
+--------------------------------------
+현재 턴: [초(CHO) 진영]
+
+     a   b   c   d   e   f   g   h   i
+ 0  한차 한마 한상 한사 ... 한사 한마 한상 한차
+ 1  ... ... ... ... 한궁 ... ... ... ...
+ 2  ... 한포 ... ... ... ... ... 한포 ...
+ 3  한병 ... 한병 ... 한병 ... 한병 ... 한병
+ 4  ... ... ... ... ... ... ... ... ...
+ 5  ... ... ... ... ... ... ... ... ...
+ 6  초졸 ... 초졸 ... 초졸 ... 초졸 ... 초졸
+ 7  ... 초포 ... ... ... ... ... 초포 ...
+ 8  ... ... ... ... 초궁 ... ... ... ...
+ 9  초차 초마 초상 초사 ... 초사 초상 초마 초차
+ 
+ [초(CHO) 진영] {출발 좌표} {도착 좌표} 형식으로 입력해 수를 두세요. (ex. e6 e5) 
+ > 영기
+ 
+ [ERROR] 좌표 형식이 틀렸습니다!
+ 
+ --------------------------------------
+ 현재 턴: [초(CHO) 진영]
+
+     a   b   c   d   e   f   g   h   i
+ 0  한차 한마 한상 한사 ... 한사 한마 한상 한차
+ 1  ... ... ... ... 한궁 ... ... ... ...
+ 2  ... 한포 ... ... ... ... ... 한포 ...
+ 3  한병 ... 한병 ... 한병 ... 한병 ... 한병
+ 4  ... ... ... ... ... ... ... ... ...
+ 5  ... ... ... ... ... ... ... ... ...
+ 6  초졸 ... 초졸 ... 초졸 ... 초졸 ... 초졸
+ 7  ... 초포 ... ... ... ... ... 초포 ...
+ 8  ... ... ... ... 초궁 ... ... ... ...
+ 9  초차 초마 초상 초사 ... 초사 초상 초마 초차
+ 
+ [초(CHO) 진영] {출발 좌표} {도착 좌표} 형식으로 입력해 수를 두세요. (ex. e6 e5)  
+ >
+```
+
+---
+
+## 4️⃣ 커밋 컨벤션
+
+Following convention : https://gist.github.com/stephenparish/9941e89d80e2bc58a153
+
+```markdown
+# basic structure
+<type>(<scope>): <subject>
+<BLANK LINE>
+<body>
+<BLANK LINE>
+<footer>
+
+# <type>
+feat (feature)
+fix (bug fix)
+docs (documentation)
+style (formatting, missing semi colons, …)
+refactor
+test (when adding missing tests)
+chore (maintain)
+
+# <scope>
+console - I/O
+domain - 핵심 로직
+validation - 유효성검사
+test - 테스트코드 추가
+```
diff --git a/build.gradle b/build.gradle
index ce846f70cc..e4d95a07c9 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,5 +1,6 @@
 plugins {
     id 'java'
+    id 'jacoco'
 }
 
 version '1.0-SNAPSHOT'
diff --git a/src/main/java/Application.java b/src/main/java/Application.java
new file mode 100644
index 0000000000..6db2f84c1c
--- /dev/null
+++ b/src/main/java/Application.java
@@ -0,0 +1,8 @@
+import io.GameConsole;
+
+public class Application {
+    public static void main(String[] args) {
+        GameConsole gameConsole = new GameConsole();
+        gameConsole.run();
+    }
+}
diff --git a/src/main/java/domain/board/Board.java b/src/main/java/domain/board/Board.java
new file mode 100644
index 0000000000..03515d9f10
--- /dev/null
+++ b/src/main/java/domain/board/Board.java
@@ -0,0 +1,74 @@
+package domain.board;
+
+import domain.game.Turn;
+import domain.movement.Movement;
+import domain.movement.MovementFactory;
+import domain.movement.MovementValidator;
+import domain.movement.Paths;
+import domain.piece.Piece;
+import domain.setup.Arrangements;
+import domain.setup.Coordinate;
+import java.util.Optional;
+
+public class Board {
+    private final Pieces pieces;
+
+    public Board(Pieces pieces) {
+        this.pieces = pieces;
+    }
+
+    public static Board of(Arrangements arrangements) {
+        return new Board(Pieces.of(arrangements));
+    }
+
+    public Board move(Coordinate coordinate, Turn turn) {
+        validateMove(coordinate, turn);
+        Position from = coordinate.from();
+        Position to = coordinate.to();
+        return new Board(pieces.move(from, to));
+    }
+
+    public Optional<Piece> pieceAt(Position position) {
+        return pieces.at(position);
+    }
+
+    public boolean isEmpty(Position position) {
+        return pieces.at(position).isEmpty();
+    }
+
+    public boolean hasAnyPiece(Position position) {
+        return !isEmpty(position);
+    }
+
+    public boolean hasFriendOf(Position position, Piece movingPiece) {
+        return pieces.at(position)
+                .map(movingPiece::isSameTeamAs)
+                .orElse(false);
+    }
+
+    public boolean hasEnemyOf(Position position, Piece movingPiece) {
+        return pieces.at(position)
+                .map(targetPiece -> !movingPiece.isSameTeamAs(targetPiece))
+                .orElse(false);
+    }
+
+    private void validateMove(Coordinate coordinate, Turn turn) {
+        Position from = coordinate.from();
+        Position to = coordinate.to();
+
+        Piece piece = pieces.at(from)
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 해당 좌표에 기물이 없습니다: " + from));
+
+        if (!turn.belongsTo(piece)) {
+            throw new IllegalArgumentException("[ERROR] 출발 좌표의 기물이 상대 기물입니다.");
+        }
+
+        Movement movement = MovementFactory.create(piece);
+        Paths paths = movement.candidatePaths(from);
+
+        MovementValidator validator = new MovementValidator(this);
+        if (!validator.isValid(piece, paths, to)) {
+            throw new IllegalArgumentException("[ERROR] 유효하지 않은 움직임입니다.");
+        }
+    }
+}
diff --git a/src/main/java/domain/board/Column.java b/src/main/java/domain/board/Column.java
new file mode 100644
index 0000000000..22cf53a283
--- /dev/null
+++ b/src/main/java/domain/board/Column.java
@@ -0,0 +1,33 @@
+package domain.board;
+
+import java.util.Arrays;
+
+public enum Column {
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    G,
+    H,
+    I;
+
+    public boolean canShift(int delta) {
+        int next = this.ordinal() + delta;
+        return next >= 0 && next < Column.values().length;
+    }
+
+    public Column shift(int delta) {
+        return Column.values()[this.ordinal() + delta];
+    }
+
+    public static Column toColumn(char character) {
+        char upperChar = Character.toUpperCase(character);
+
+        return Arrays.stream(values())
+                .filter(column -> column.name().charAt(0) == upperChar)
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 올바른 열 값이 아닙니다."));
+    }
+}
diff --git a/src/main/java/domain/board/Pieces.java b/src/main/java/domain/board/Pieces.java
new file mode 100644
index 0000000000..c201be6e4e
--- /dev/null
+++ b/src/main/java/domain/board/Pieces.java
@@ -0,0 +1,34 @@
+package domain.board;
+
+import domain.piece.Piece;
+import domain.setup.Arrangements;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public class Pieces {
+    private final Map<Position, Piece> pieces;
+
+    public Pieces(Map<Position, Piece> pieces) {
+        this.pieces = new HashMap<>(pieces);
+    }
+
+    public static Pieces of(Arrangements arrangements) {
+        return new Pieces(PositionLayout.build(arrangements));
+    }
+
+    public Pieces move(Position from, Position to) {
+        Piece piece = pieces.get(from);
+        if (piece == null) {
+            throw new IllegalArgumentException("[ERROR] 해당 위치에 기물이 없습니다: " + from);
+        }
+        Map<Position, Piece> newMap = new HashMap<>(pieces);
+        newMap.remove(from);
+        newMap.put(to, piece);
+        return new Pieces(newMap);
+    }
+
+    public Optional<Piece> at(Position position) {
+        return Optional.ofNullable(pieces.get(position));
+    }
+}
diff --git a/src/main/java/domain/board/Position.java b/src/main/java/domain/board/Position.java
new file mode 100644
index 0000000000..d432f2daef
--- /dev/null
+++ b/src/main/java/domain/board/Position.java
@@ -0,0 +1,16 @@
+package domain.board;
+
+import domain.movement.Delta;
+
+public record Position(Column column, Row row) {
+    public boolean canShift(Delta delta) {
+        return column.canShift(delta.columnDelta().value()) && row.canShift(delta.rowDelta().value());
+    }
+
+    public Position shift(Delta delta) {
+        return new Position(
+                column.shift(delta.columnDelta().value()),
+                row.shift(delta.rowDelta().value())
+        );
+    }
+}
diff --git a/src/main/java/domain/board/PositionLayout.java b/src/main/java/domain/board/PositionLayout.java
new file mode 100644
index 0000000000..7ef9f098ca
--- /dev/null
+++ b/src/main/java/domain/board/PositionLayout.java
@@ -0,0 +1,65 @@
+package domain.board;
+
+import domain.piece.Piece;
+import domain.setup.Arrangements;
+import domain.piece.PieceType;
+import domain.piece.Team;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class PositionLayout {
+    private static final Map<Position, PieceType> HAN_PIECES_LAYOUT = Map.ofEntries(
+            Map.entry(new Position(Column.A, Row.ZERO), PieceType.CHARIOT),
+            Map.entry(new Position(Column.D, Row.ZERO), PieceType.GUARD),
+            Map.entry(new Position(Column.E, Row.ONE), PieceType.GENERAL),
+            Map.entry(new Position(Column.F, Row.ZERO), PieceType.GUARD),
+            Map.entry(new Position(Column.I, Row.ZERO), PieceType.CHARIOT),
+            Map.entry(new Position(Column.B, Row.TWO), PieceType.CANNON),
+            Map.entry(new Position(Column.H, Row.TWO), PieceType.CANNON),
+            Map.entry(new Position(Column.A, Row.THREE), PieceType.SOLDIER),
+            Map.entry(new Position(Column.C, Row.THREE), PieceType.SOLDIER),
+            Map.entry(new Position(Column.E, Row.THREE), PieceType.SOLDIER),
+            Map.entry(new Position(Column.G, Row.THREE), PieceType.SOLDIER),
+            Map.entry(new Position(Column.I, Row.THREE), PieceType.SOLDIER)
+    );
+
+    private static final List<Column> INNER_COLUMNS = List.of(Column.B, Column.C, Column.G, Column.H);
+
+    public static Map<Position, Piece> build(Arrangements arrangements) {
+        Map<Position, Piece> result = new HashMap<>();
+        placeHanPieces(result);
+        placeHanInnerPieces(result, arrangements);
+        placeChoPieces(result);
+        placeCHoInnerPieces(result, arrangements);
+        return result;
+    }
+
+    private static void placeHanPieces(Map<Position, Piece> result) {
+        HAN_PIECES_LAYOUT.forEach((position, pieceType) ->
+                result.put(position, new Piece(Team.HAN, pieceType)));
+    }
+
+    private static void placeHanInnerPieces(Map<Position, Piece> result, Arrangements arrangements) {
+        List<PieceType> innerPieces = arrangements.arrangeFor(Team.HAN).innerPieces();
+        for (int index = 0; index < INNER_COLUMNS.size(); index++) {
+            result.put(new Position(INNER_COLUMNS.get(index), Row.ZERO), new Piece(Team.HAN, innerPieces.get(index)));
+        }
+    }
+
+    private static void placeChoPieces(Map<Position, Piece> result) {
+        HAN_PIECES_LAYOUT.forEach((position, pieceType) -> {
+            Position reversedPosition = new Position(position.column(), position.row().reverse());
+            result.put(reversedPosition, new Piece(Team.CHO, pieceType));
+        });
+    }
+
+    private static void placeCHoInnerPieces(Map<Position, Piece> result, Arrangements arrangements) {
+        List<PieceType> innerPieces = arrangements.arrangeFor(Team.CHO).innerPieces();
+        for (int index = 0; index < INNER_COLUMNS.size(); index++) {
+            result.put(new Position(INNER_COLUMNS.get(index), Row.ZERO.reverse()),
+                    new Piece(Team.CHO, innerPieces.get(index)));
+        }
+    }
+
+}
diff --git a/src/main/java/domain/board/Row.java b/src/main/java/domain/board/Row.java
new file mode 100644
index 0000000000..2e6fbc307a
--- /dev/null
+++ b/src/main/java/domain/board/Row.java
@@ -0,0 +1,49 @@
+package domain.board;
+
+import java.util.Arrays;
+
+public enum Row {
+    ZERO("0"),
+    ONE("1"),
+    TWO("2"),
+    THREE("3"),
+    FOUR("4"),
+    FIVE("5"),
+    SIX("6"),
+    SEVEN("7"),
+    EIGHT("8"),
+    NINE("9");
+
+
+    private final String value;
+
+    Row(String value) {
+        this.value = value;
+    }
+
+    public boolean canShift(int delta) {
+        int next = this.ordinal() + delta;
+        return next >= 0 && next < Row.values().length;
+    }
+
+    public Row shift(int delta) {
+        return Row.values()[this.ordinal() + delta];
+    }
+
+    public Row reverse() {
+        return Row.values()[9 - this.ordinal()];
+    }
+
+    public String display() {
+        return value;
+    }
+
+    public static Row toRow(char character) {
+        String upperChar = String.valueOf(character);
+
+        return Arrays.stream(Row.values())
+                .filter(row -> row.value.equals(upperChar))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 올바른 행 값이 아닙니다."));
+    }
+}
diff --git a/src/main/java/domain/game/JanggiGame.java b/src/main/java/domain/game/JanggiGame.java
new file mode 100644
index 0000000000..960280b935
--- /dev/null
+++ b/src/main/java/domain/game/JanggiGame.java
@@ -0,0 +1,55 @@
+package domain.game;
+
+import domain.board.Board;
+import domain.piece.Team;
+import domain.setup.Arrangements;
+import domain.setup.Command;
+import domain.setup.Coordinate;
+import domain.state.GamePhase;
+import domain.state.GameState;
+import domain.state.ReadyState;
+
+public class JanggiGame {
+    private Turn turn;
+    private GameState gameState;
+    private Board board;
+
+    public JanggiGame() {
+        this.turn = new Turn(Team.HAN);
+        this.gameState = new ReadyState(new Arrangements());
+    }
+
+    public void processCommand(Command command) {
+        gameState = gameState.handle(this, command);
+    }
+
+    public void setupBoard(Arrangements arrangements) {
+        this.board = Board.of(arrangements);
+        this.turn = new Turn(Team.CHO);
+    }
+
+    public Board getBoard() {
+        return board;
+    }
+
+    public Turn getTurn() {
+        return turn;
+    }
+
+    public void move(Coordinate coordinate) {
+        this.board = board.move(coordinate, turn);
+    }
+
+    public void nextTurn() {
+        this.turn = turn.changeTeam();
+    }
+
+    public boolean isReadyPhase() {
+        return gameState.phase() == GamePhase.READY;
+    }
+
+    public boolean isPlayingPhase() {
+        return gameState.phase() == GamePhase.PLAYING;
+    }
+
+}
diff --git a/src/main/java/domain/game/Turn.java b/src/main/java/domain/game/Turn.java
new file mode 100644
index 0000000000..14c01dd75e
--- /dev/null
+++ b/src/main/java/domain/game/Turn.java
@@ -0,0 +1,28 @@
+package domain.game;
+
+import domain.piece.Piece;
+import domain.piece.Team;
+
+public class Turn {
+    private final Team team;
+
+    public Turn(Team team) {
+        this.team = team;
+    }
+
+    public String display() {
+        return team.display();
+    }
+
+    public String colorCode(String red, String green) {
+        return team.colorCode(red, green);
+    }
+
+    public boolean belongsTo(Piece piece) {
+        return piece.isOwnedBy(team);
+    }
+
+    public Turn changeTeam() {
+        return new Turn(team.enemy());
+    }
+}
diff --git a/src/main/java/domain/movement/ChariotOrCannonMovement.java b/src/main/java/domain/movement/ChariotOrCannonMovement.java
new file mode 100644
index 0000000000..9b1b18d873
--- /dev/null
+++ b/src/main/java/domain/movement/ChariotOrCannonMovement.java
@@ -0,0 +1,40 @@
+package domain.movement;
+
+import domain.board.Position;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ChariotOrCannonMovement implements Movement {
+    private static final List<Delta> MOVES = List.of(
+            new Delta(new ColumnDelta(0), new RowDelta(-1)),
+            new Delta(new ColumnDelta(0), new RowDelta(1)),
+            new Delta(new ColumnDelta(-1), new RowDelta(0)),
+            new Delta(new ColumnDelta(1), new RowDelta(0))
+    );
+
+    @Override
+    public Paths candidatePaths(Position from) {
+        Paths paths = Paths.empty();
+        for (Delta delta : MOVES) {
+            paths = addLinePath(paths, from, delta);
+        }
+        return paths;
+    }
+
+    private Paths addLinePath(Paths paths, Position from, Delta delta) {
+        if (!from.canShift(delta)) {
+            return paths;
+        }
+        return paths.add(new Path(buildLine(from, delta)));
+    }
+
+    private List<Position> buildLine(Position from, Delta delta) {
+        List<Position> path = new ArrayList<>();
+        Position nextPosition = from;
+        while (nextPosition.canShift(delta)) {
+            nextPosition = nextPosition.shift(delta);
+            path.add(nextPosition);
+        }
+        return path;
+    }
+}
diff --git a/src/main/java/domain/movement/ColumnDelta.java b/src/main/java/domain/movement/ColumnDelta.java
new file mode 100644
index 0000000000..22f252bb38
--- /dev/null
+++ b/src/main/java/domain/movement/ColumnDelta.java
@@ -0,0 +1,4 @@
+package domain.movement;
+
+public record ColumnDelta(int value) {
+}
diff --git a/src/main/java/domain/movement/Delta.java b/src/main/java/domain/movement/Delta.java
new file mode 100644
index 0000000000..641585582d
--- /dev/null
+++ b/src/main/java/domain/movement/Delta.java
@@ -0,0 +1,4 @@
+package domain.movement;
+
+public record Delta(ColumnDelta columnDelta, RowDelta rowDelta) {
+}
diff --git a/src/main/java/domain/movement/ElephantMovement.java b/src/main/java/domain/movement/ElephantMovement.java
new file mode 100644
index 0000000000..00d027e0b5
--- /dev/null
+++ b/src/main/java/domain/movement/ElephantMovement.java
@@ -0,0 +1,63 @@
+package domain.movement;
+
+import domain.board.Position;
+import java.util.List;
+
+public class ElephantMovement implements Movement {
+
+    private record ElephantMove(Delta orthogonalDelta, Delta firstDiagonalDelta, Delta secondDiagonalDelta) {
+    }
+
+    private static final List<ElephantMove> MOVES = List.of(
+            new ElephantMove(
+                    new Delta(new ColumnDelta(0), new RowDelta(-1)),
+                    new Delta(new ColumnDelta(-1), new RowDelta(-1)),
+                    new Delta(new ColumnDelta(1), new RowDelta(-1))
+            ),
+            new ElephantMove(
+                    new Delta(new ColumnDelta(0), new RowDelta(1)),
+                    new Delta(new ColumnDelta(-1), new RowDelta(1)),
+                    new Delta(new ColumnDelta(1), new RowDelta(1))
+            ),
+            new ElephantMove(
+                    new Delta(new ColumnDelta(-1), new RowDelta(0)),
+                    new Delta(new ColumnDelta(-1), new RowDelta(-1)),
+                    new Delta(new ColumnDelta(-1), new RowDelta(1))
+            ),
+            new ElephantMove(
+                    new Delta(new ColumnDelta(1), new RowDelta(0)),
+                    new Delta(new ColumnDelta(1), new RowDelta(-1)),
+                    new Delta(new ColumnDelta(1), new RowDelta(1))
+            )
+    );
+
+    @Override
+    public Paths candidatePaths(Position from) {
+        Paths paths = Paths.empty();
+        for (ElephantMove move : MOVES) {
+            paths = addMovePaths(paths, from, move);
+        }
+        return paths;
+    }
+
+    private Paths addMovePaths(Paths paths, Position from, ElephantMove move) {
+        if (!from.canShift(move.orthogonalDelta())) {
+            return paths;
+        }
+        Position blocking = from.shift(move.orthogonalDelta());
+        paths = addDiagonalPath(paths, blocking, move.firstDiagonalDelta());
+        return addDiagonalPath(paths, blocking, move.secondDiagonalDelta());
+    }
+
+    private Paths addDiagonalPath(Paths paths, Position blocking, Delta diagonalDelta) {
+        if (!blocking.canShift(diagonalDelta)) {
+            return paths;
+        }
+        Position diagBlocking = blocking.shift(diagonalDelta);
+        if (!diagBlocking.canShift(diagonalDelta)) {
+            return paths;
+        }
+        Position destination = diagBlocking.shift(diagonalDelta);
+        return paths.add(new Path(List.of(blocking, diagBlocking, destination)));
+    }
+}
diff --git a/src/main/java/domain/movement/GeneralMovement.java b/src/main/java/domain/movement/GeneralMovement.java
new file mode 100644
index 0000000000..f157cf3e09
--- /dev/null
+++ b/src/main/java/domain/movement/GeneralMovement.java
@@ -0,0 +1,29 @@
+package domain.movement;
+
+import domain.board.Position;
+import java.util.List;
+
+public class GeneralMovement implements Movement {
+    private static final List<Delta> MOVES = List.of(
+            new Delta(new ColumnDelta(0), new RowDelta(-1)),
+            new Delta(new ColumnDelta(0), new RowDelta(1)),
+            new Delta(new ColumnDelta(-1), new RowDelta(0)),
+            new Delta(new ColumnDelta(1), new RowDelta(0))
+    );
+
+    @Override
+    public Paths candidatePaths(Position from) {
+        Paths paths = Paths.empty();
+        for (Delta delta : MOVES) {
+            paths = addPathIfReachable(paths, from, delta);
+        }
+        return paths;
+    }
+
+    private Paths addPathIfReachable(Paths paths, Position from, Delta delta) {
+        if (!from.canShift(delta)) {
+            return paths;
+        }
+        return paths.add(new Path(List.of(from.shift(delta))));
+    }
+}
diff --git a/src/main/java/domain/movement/GuardMovement.java b/src/main/java/domain/movement/GuardMovement.java
new file mode 100644
index 0000000000..5904878618
--- /dev/null
+++ b/src/main/java/domain/movement/GuardMovement.java
@@ -0,0 +1,29 @@
+package domain.movement;
+
+import domain.board.Position;
+import java.util.List;
+
+public class GuardMovement implements Movement {
+    private static final List<Delta> MOVES = List.of(
+            new Delta(new ColumnDelta(0), new RowDelta(-1)),
+            new Delta(new ColumnDelta(0), new RowDelta(1)),
+            new Delta(new ColumnDelta(-1), new RowDelta(0)),
+            new Delta(new ColumnDelta(1), new RowDelta(0))
+    );
+
+    @Override
+    public Paths candidatePaths(Position from) {
+        Paths paths = Paths.empty();
+        for (Delta delta : MOVES) {
+            paths = addPathIfReachable(paths, from, delta);
+        }
+        return paths;
+    }
+
+    private Paths addPathIfReachable(Paths paths, Position from, Delta delta) {
+        if (!from.canShift(delta)) {
+            return paths;
+        }
+        return paths.add(new Path(List.of(from.shift(delta))));
+    }
+}
diff --git a/src/main/java/domain/movement/HorseMovement.java b/src/main/java/domain/movement/HorseMovement.java
new file mode 100644
index 0000000000..d16b0ca45e
--- /dev/null
+++ b/src/main/java/domain/movement/HorseMovement.java
@@ -0,0 +1,59 @@
+package domain.movement;
+
+import domain.board.Position;
+import java.util.List;
+
+public final class HorseMovement implements Movement {
+
+    private record HorseMove(Delta orthogonalDelta, Delta firstDiagonalDelta, Delta secondDiagonalDelta) {
+    }
+
+    private static final List<HorseMove> MOVES = List.of(
+            new HorseMove(
+                    new Delta(new ColumnDelta(0), new RowDelta(-1)),
+                    new Delta(new ColumnDelta(-1), new RowDelta(-1)),
+                    new Delta(new ColumnDelta(1), new RowDelta(-1))
+            ),
+            new HorseMove(
+                    new Delta(new ColumnDelta(0), new RowDelta(1)),
+                    new Delta(new ColumnDelta(-1), new RowDelta(1)),
+                    new Delta(new ColumnDelta(1), new RowDelta(1))
+            ),
+            new HorseMove(
+                    new Delta(new ColumnDelta(-1), new RowDelta(0)),
+                    new Delta(new ColumnDelta(-1), new RowDelta(-1)),
+                    new Delta(new ColumnDelta(-1), new RowDelta(1))
+            ),
+            new HorseMove(
+                    new Delta(new ColumnDelta(1), new RowDelta(0)),
+                    new Delta(new ColumnDelta(1), new RowDelta(-1)),
+                    new Delta(new ColumnDelta(1), new RowDelta(1))
+            )
+    );
+
+    @Override
+    public Paths candidatePaths(Position from) {
+        Paths paths = Paths.empty();
+        for (HorseMove move : MOVES) {
+            paths = addMovePaths(paths, from, move);
+        }
+        return paths;
+    }
+
+    private Paths addMovePaths(Paths paths, Position from, HorseMove move) {
+        if (!from.canShift(move.orthogonalDelta())) {
+            return paths;
+        }
+        Position blocking = from.shift(move.orthogonalDelta());
+        paths = addDiagonalPath(paths, blocking, move.firstDiagonalDelta());
+        return addDiagonalPath(paths, blocking, move.secondDiagonalDelta());
+    }
+
+    private Paths addDiagonalPath(Paths paths, Position blocking, Delta diagonalDelta) {
+        if (!blocking.canShift(diagonalDelta)) {
+            return paths;
+        }
+        Position destination = blocking.shift(diagonalDelta);
+        return paths.add(new Path(List.of(blocking, destination)));
+    }
+}
diff --git a/src/main/java/domain/movement/Movement.java b/src/main/java/domain/movement/Movement.java
new file mode 100644
index 0000000000..a47575a659
--- /dev/null
+++ b/src/main/java/domain/movement/Movement.java
@@ -0,0 +1,7 @@
+package domain.movement;
+
+import domain.board.Position;
+
+public interface Movement {
+    Paths candidatePaths(Position from);
+}
diff --git a/src/main/java/domain/movement/MovementFactory.java b/src/main/java/domain/movement/MovementFactory.java
new file mode 100644
index 0000000000..55711bd8f5
--- /dev/null
+++ b/src/main/java/domain/movement/MovementFactory.java
@@ -0,0 +1,36 @@
+package domain.movement;
+
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.piece.Team;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.function.Function;
+
+public final class MovementFactory {
+    private static final Map<PieceType, Function<Piece, Movement>> MOVEMENT_SUPPLIERS = new EnumMap<>(PieceType.class);
+
+    static {
+        MOVEMENT_SUPPLIERS.put(PieceType.GENERAL, piece -> new GeneralMovement());
+        MOVEMENT_SUPPLIERS.put(PieceType.GUARD, piece -> new GuardMovement());
+        MOVEMENT_SUPPLIERS.put(PieceType.CHARIOT, piece -> new ChariotOrCannonMovement());
+        MOVEMENT_SUPPLIERS.put(PieceType.CANNON, piece -> new ChariotOrCannonMovement());
+        MOVEMENT_SUPPLIERS.put(PieceType.ELEPHANT, piece -> new ElephantMovement());
+        MOVEMENT_SUPPLIERS.put(PieceType.HORSE, piece -> new HorseMovement());
+        MOVEMENT_SUPPLIERS.put(PieceType.SOLDIER, MovementFactory::soldierMovementFor);
+    }
+
+    private MovementFactory() {
+    }
+
+    public static Movement create(Piece piece) {
+        return MOVEMENT_SUPPLIERS.get(piece.getPieceType()).apply(piece);
+    }
+
+    private static Movement soldierMovementFor(Piece piece) {
+        if (piece.isOwnedBy(Team.HAN)) {
+            return new SoldierMovement(Team.HAN);
+        }
+        return new SoldierMovement(Team.CHO);
+    }
+}
diff --git a/src/main/java/domain/movement/MovementValidator.java b/src/main/java/domain/movement/MovementValidator.java
new file mode 100644
index 0000000000..e3057d6bef
--- /dev/null
+++ b/src/main/java/domain/movement/MovementValidator.java
@@ -0,0 +1,159 @@
+package domain.movement;
+
+import domain.board.Board;
+import domain.board.Position;
+import domain.piece.Piece;
+import java.util.List;
+import java.util.Optional;
+
+public final class MovementValidator {
+    private final Board board;
+
+    public MovementValidator(Board board) {
+        this.board = board;
+    }
+
+    public boolean isValid(Piece piece, Paths candidatePaths, Position to) {
+        if (board.hasFriendOf(to, piece)) {
+            return false;
+        }
+        return isValidForType(piece, candidatePaths, to);
+    }
+
+    private boolean isValidForType(Piece piece, Paths candidatePaths, Position to) {
+        if (piece.isChariot()) {
+            return isValidChariot(piece, candidatePaths, to);
+        }
+        if (piece.isCannon()) {
+            return isValidCannon(piece, candidatePaths, to);
+        }
+        if (piece.isHorseOrElephant()) {
+            return isValidHorseOrElephant(piece, candidatePaths, to);
+        }
+        return isValidPalacePiece(piece, candidatePaths, to);
+    }
+
+    private boolean isValidChariot(Piece piece, Paths candidatePaths, Position to) {
+        for (Path path : candidatePaths.asList()) {
+            if (isChariotPathValid(piece, path, to)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isChariotPathValid(Piece piece, Path path, Position to) {
+        if (!path.contains(to)) {
+            return false;
+        }
+        if (!isPathClearTo(path, to)) {
+            return false;
+        }
+        return board.isEmpty(to) || board.hasEnemyOf(to, piece);
+    }
+
+    private boolean isPathClearTo(Path path, Position to) {
+        Path subPath = path.subPathTo(to);
+        List<Position> intermediates = subPath.intermediates();
+        return intermediates.stream().allMatch(board::isEmpty);
+    }
+
+    private boolean isValidCannon(Piece piece, Paths candidatePaths, Position to) {
+        for (Path path : candidatePaths.asList()) {
+            if (isCannonPathValid(piece, path, to)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isCannonPathValid(Piece piece, Path path, Position to) {
+        if (!path.contains(to)) {
+            return false;
+        }
+        Path subPath = path.subPathTo(to);
+        List<Position> intermediates = subPath.intermediates();
+        if (!hasExactlyOneNonCannon(intermediates)) {
+            return false;
+        }
+        return isValidCannonDestination(piece, to);
+    }
+
+    private boolean hasExactlyOneNonCannon(List<Position> intermediates) {
+        return countNonCannons(intermediates) == 1 && countCannons(intermediates) == 0;
+    }
+
+    private long countNonCannons(List<Position> intermediates) {
+        return intermediates.stream()
+                .filter(board::hasAnyPiece)
+                .filter(this::isNonCannonAt)
+                .count();
+    }
+
+    private boolean isNonCannonAt(Position position) {
+        Optional<Piece> foundPiece = board.pieceAt(position);
+        Optional<Boolean> isNotCannon = foundPiece.map(piece -> !piece.isCannon());
+        return isNotCannon.orElse(false);
+    }
+
+    private long countCannons(List<Position> intermediates) {
+        return intermediates.stream()
+                .filter(board::hasAnyPiece)
+                .filter(this::isCannonAt)
+                .count();
+    }
+
+    private boolean isCannonAt(Position position) {
+        Optional<Piece> foundPiece = board.pieceAt(position);
+        Optional<Boolean> isCannon = foundPiece.map(Piece::isCannon);
+        return isCannon.orElse(false);
+    }
+
+    private boolean isValidCannonDestination(Piece piece, Position to) {
+        if (board.isEmpty(to)) {
+            return true;
+        }
+        if (!board.hasEnemyOf(to, piece)) {
+            return false;
+        }
+        Optional<Piece> target = board.pieceAt(to);
+        Optional<Boolean> isCannon = target.map(Piece::isCannon);
+        return !isCannon.orElse(false);
+    }
+
+    private boolean isValidHorseOrElephant(Piece piece, Paths candidatePaths, Position to) {
+        for (Path path : candidatePaths.asList()) {
+            if (isHorseOrElephantPathValid(piece, path, to)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isHorseOrElephantPathValid(Piece piece, Path path, Position to) {
+        if (!path.endsAt(to)) {
+            return false;
+        }
+        List<Position> intermediates = path.intermediates();
+        if (!intermediates.stream().allMatch(board::isEmpty)) {
+            return false;
+        }
+        return board.isEmpty(to) || board.hasEnemyOf(to, piece);
+    }
+
+    private boolean isValidPalacePiece(Piece piece, Paths candidatePaths, Position to) {
+        for (Path path : candidatePaths.asList()) {
+            if (isReachable(piece, path, to)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isReachable(Piece piece, Path path, Position to) {
+        if (!path.endsAt(to)) {
+            return false;
+        }
+        return board.isEmpty(to) || board.hasEnemyOf(to, piece);
+    }
+}
diff --git a/src/main/java/domain/movement/Path.java b/src/main/java/domain/movement/Path.java
new file mode 100644
index 0000000000..7f726bfb53
--- /dev/null
+++ b/src/main/java/domain/movement/Path.java
@@ -0,0 +1,37 @@
+package domain.movement;
+
+import domain.board.Position;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public final class Path {
+    private final List<Position> positions;
+
+    public Path(List<Position> positions) {
+        if (positions == null || positions.isEmpty()) {
+            throw new IllegalArgumentException("[ERROR] 경로는 적어도 하나 이상의 포지션을 가져야 합니다.");
+        }
+        this.positions = Collections.unmodifiableList(new ArrayList<>(positions));
+    }
+
+    public boolean contains(Position position) {
+        return positions.contains(position);
+    }
+
+    public boolean endsAt(Position position) {
+        return positions.get(positions.size() - 1).equals(position);
+    }
+
+    public List<Position> intermediates() {
+        return positions.subList(0, positions.size() - 1);
+    }
+
+    public Path subPathTo(Position position) {
+        int index = positions.indexOf(position);
+        if (index == -1) {
+            throw new IllegalArgumentException("[ERROR] 해당 포지션이 경로에 없습니다: " + position);
+        }
+        return new Path(positions.subList(0, index + 1));
+    }
+}
diff --git a/src/main/java/domain/movement/Paths.java b/src/main/java/domain/movement/Paths.java
new file mode 100644
index 0000000000..feaeeff448
--- /dev/null
+++ b/src/main/java/domain/movement/Paths.java
@@ -0,0 +1,26 @@
+package domain.movement;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class Paths {
+    private final List<Path> paths;
+
+    public Paths(List<Path> paths) {
+        this.paths = List.copyOf(paths);
+    }
+
+    public static Paths empty() {
+        return new Paths(new ArrayList<>());
+    }
+
+    public Paths add(Path path) {
+        List<Path> newPaths = new ArrayList<>(paths);
+        newPaths.add(path);
+        return new Paths(newPaths);
+    }
+
+    public List<Path> asList() {
+        return paths;
+    }
+}
diff --git a/src/main/java/domain/movement/RowDelta.java b/src/main/java/domain/movement/RowDelta.java
new file mode 100644
index 0000000000..cfd5006511
--- /dev/null
+++ b/src/main/java/domain/movement/RowDelta.java
@@ -0,0 +1,4 @@
+package domain.movement;
+
+public record RowDelta(int value) {
+}
diff --git a/src/main/java/domain/movement/SoldierMovement.java b/src/main/java/domain/movement/SoldierMovement.java
new file mode 100644
index 0000000000..b978cea417
--- /dev/null
+++ b/src/main/java/domain/movement/SoldierMovement.java
@@ -0,0 +1,47 @@
+package domain.movement;
+
+import domain.board.Position;
+import domain.piece.Team;
+import java.util.List;
+
+public class SoldierMovement implements Movement {
+    private static final List<Delta> MOVES_HAN = List.of(
+            new Delta(new ColumnDelta(0), new RowDelta(1)),
+            new Delta(new ColumnDelta(-1), new RowDelta(0)),
+            new Delta(new ColumnDelta(1), new RowDelta(0))
+    );
+    private static final List<Delta> MOVES_CHO = List.of(
+            new Delta(new ColumnDelta(0), new RowDelta(-1)),
+            new Delta(new ColumnDelta(-1), new RowDelta(0)),
+            new Delta(new ColumnDelta(1), new RowDelta(0))
+    );
+
+    private final Team team;
+
+    public SoldierMovement(Team team) {
+        this.team = team;
+    }
+
+    @Override
+    public Paths candidatePaths(Position from) {
+        Paths paths = Paths.empty();
+        for (Delta delta : teamMoves()) {
+            paths = addPathIfReachable(paths, from, delta);
+        }
+        return paths;
+    }
+
+    private Paths addPathIfReachable(Paths paths, Position from, Delta delta) {
+        if (!from.canShift(delta)) {
+            return paths;
+        }
+        return paths.add(new Path(List.of(from.shift(delta))));
+    }
+
+    private List<Delta> teamMoves() {
+        if (team == Team.HAN) {
+            return MOVES_HAN;
+        }
+        return MOVES_CHO;
+    }
+}
diff --git a/src/main/java/domain/piece/Piece.java b/src/main/java/domain/piece/Piece.java
new file mode 100644
index 0000000000..19cad3b3e9
--- /dev/null
+++ b/src/main/java/domain/piece/Piece.java
@@ -0,0 +1,47 @@
+package domain.piece;
+
+public class Piece {
+    private final Team team;
+    private final PieceType pieceType;
+
+    public Piece(Team team, PieceType pieceType) {
+        this.team = team;
+        this.pieceType = pieceType;
+    }
+
+    public String display() {
+        return team.displayPiece(pieceType);
+    }
+
+    public String colorCode(String red, String green) {
+        return team.colorCode(red, green);
+    }
+
+    public PieceType getPieceType() {
+        return pieceType;
+    }
+
+    public boolean isChariot() {
+        return pieceType == PieceType.CHARIOT;
+    }
+
+    public boolean isCannon() {
+        return pieceType == PieceType.CANNON;
+    }
+
+    public boolean isHorseOrElephant() {
+        return pieceType == PieceType.HORSE || pieceType == PieceType.ELEPHANT;
+    }
+
+    public boolean isSoldier() {
+        return pieceType == PieceType.SOLDIER;
+    }
+
+    public boolean isOwnedBy(Team targetTeam) {
+        return this.team == targetTeam;
+    }
+
+    public boolean isSameTeamAs(Piece other) {
+        return this.team == other.team;
+    }
+}
diff --git a/src/main/java/domain/piece/PieceType.java b/src/main/java/domain/piece/PieceType.java
new file mode 100644
index 0000000000..8d9a0ec013
--- /dev/null
+++ b/src/main/java/domain/piece/PieceType.java
@@ -0,0 +1,21 @@
+package domain.piece;
+
+public enum PieceType {
+    GENERAL("궁"),
+    GUARD("사"),
+    CHARIOT("차"),
+    CANNON("포"),
+    ELEPHANT("상"),
+    HORSE("마"),
+    SOLDIER("졸");
+
+    private final String displayName;
+
+    PieceType(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String display() {
+        return displayName;
+    }
+}
diff --git a/src/main/java/domain/piece/Team.java b/src/main/java/domain/piece/Team.java
new file mode 100644
index 0000000000..c651a21b8d
--- /dev/null
+++ b/src/main/java/domain/piece/Team.java
@@ -0,0 +1,36 @@
+package domain.piece;
+
+public enum Team {
+    CHO("초(CHO)", "초"),
+    HAN("한(HAN)", "한");
+
+    private final String teamName;
+    private final String prefix;
+
+    Team(String teamName, String prefix) {
+        this.teamName = teamName;
+        this.prefix = prefix;
+    }
+
+    public String display() {
+        return teamName;
+    }
+
+    public String displayPiece(PieceType pieceType) {
+        return prefix + pieceType.display();
+    }
+
+    public String colorCode(String red, String green) {
+        if (this == HAN) {
+            return red;
+        }
+        return green;
+    }
+
+    public Team enemy() {
+        if (this == CHO) {
+            return HAN;
+        }
+        return CHO;
+    }
+}
diff --git a/src/main/java/domain/setup/Arrangement.java b/src/main/java/domain/setup/Arrangement.java
new file mode 100644
index 0000000000..dd46ef80eb
--- /dev/null
+++ b/src/main/java/domain/setup/Arrangement.java
@@ -0,0 +1,32 @@
+package domain.setup;
+
+import domain.piece.PieceType;
+import java.util.Arrays;
+import java.util.List;
+
+public enum Arrangement {
+    MASANGMASANG("1", List.of(PieceType.HORSE, PieceType.ELEPHANT, PieceType.HORSE, PieceType.ELEPHANT)),
+    MASANGSANGMA("2", List.of(PieceType.HORSE, PieceType.ELEPHANT, PieceType.ELEPHANT, PieceType.HORSE)),
+    SANGMAMASANG("3", List.of(PieceType.ELEPHANT, PieceType.HORSE, PieceType.HORSE, PieceType.ELEPHANT)),
+    SANGMASANGMA("4", List.of(PieceType.ELEPHANT, PieceType.HORSE, PieceType.ELEPHANT, PieceType.HORSE));
+
+    private final String value;
+    private final List<PieceType> innerPieces;
+
+    Arrangement(String value, List<PieceType> innerPieces) {
+        this.value = value;
+        this.innerPieces = innerPieces;
+    }
+
+    public List<PieceType> innerPieces() {
+        return innerPieces;
+    }
+
+    public static Arrangement toArrangement(String setupCommand) {
+        return Arrays.stream(values())
+                .filter(arrangement -> arrangement.value.equals(setupCommand))
+                .findAny()
+                .orElseThrow(() -> new IllegalArgumentException("[ERROR] 1~4까지의 숫자만 입력 가능합니다."));
+    }
+
+}
diff --git a/src/main/java/domain/setup/Arrangements.java b/src/main/java/domain/setup/Arrangements.java
new file mode 100644
index 0000000000..0ac2b03553
--- /dev/null
+++ b/src/main/java/domain/setup/Arrangements.java
@@ -0,0 +1,37 @@
+package domain.setup;
+
+import domain.piece.Team;
+import java.util.EnumMap;
+import java.util.Map;
+
+public class Arrangements {
+    private static final String ERROR_ARRANGEMENT_NOT_FOUND = "[ERROR] 해당 팀의 배치가 없습니다.";
+
+    private final Map<Team, Arrangement> arrangements;
+
+    public Arrangements() {
+        this.arrangements = new EnumMap<>(Team.class);
+    }
+
+    public Arrangements(Map<Team, Arrangement> arrangements) {
+        this.arrangements = new EnumMap<>(arrangements);
+    }
+
+    public Arrangements assignArrangement(Team team, Arrangement arrangement) {
+        Map<Team, Arrangement> newArrangements = new EnumMap<>(arrangements);
+        newArrangements.put(team, arrangement);
+        return new Arrangements(newArrangements);
+    }
+
+    public boolean hasArrangementFor(Team team) {
+        return arrangements.containsKey(team);
+    }
+
+    public Arrangement arrangeFor(Team team) {
+        Arrangement arrangement = arrangements.get(team);
+        if (arrangement != null) {
+            return arrangement;
+        }
+        throw new IllegalArgumentException(ERROR_ARRANGEMENT_NOT_FOUND);
+    }
+}
diff --git a/src/main/java/domain/setup/Command.java b/src/main/java/domain/setup/Command.java
new file mode 100644
index 0000000000..5f295191c5
--- /dev/null
+++ b/src/main/java/domain/setup/Command.java
@@ -0,0 +1,17 @@
+package domain.setup;
+
+public class Command {
+    private final String value;
+
+    public Command(String input) {
+        this.value = input;
+    }
+
+    public Arrangement toArrangement() {
+        return Arrangement.toArrangement(value);
+    }
+
+    public Coordinate toCoordinate() {
+        return Coordinate.toCoordinate(value);
+    }
+}
diff --git a/src/main/java/domain/setup/Coordinate.java b/src/main/java/domain/setup/Coordinate.java
new file mode 100644
index 0000000000..200abb2b31
--- /dev/null
+++ b/src/main/java/domain/setup/Coordinate.java
@@ -0,0 +1,53 @@
+package domain.setup;
+
+import domain.board.Position;
+import domain.board.Column;
+import domain.board.Row;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class Coordinate {
+    private static final Pattern POSITION_PATTERN = Pattern.compile("^[a-iA-I][0-9] [a-iA-I][0-9]$");
+    private static final int START_POSITION_INDEX = 0;
+    private static final int END_POSITION_INDEX = 1;
+    private static final int COL_POSITION_INDEX = 0;
+    private static final int ROW_POSITION_INDEX = 1;
+    private final Position start;
+    private final Position end;
+
+    private Coordinate(Position start, Position end) {
+        this.start = start;
+        this.end = end;
+    }
+
+    public static Coordinate toCoordinate(String input) {
+        validateInput(input);
+        List<String> tokens = Arrays.stream(input.split(" "))
+                .toList();
+
+        return new Coordinate(toPosition(tokens.get(START_POSITION_INDEX)), toPosition(tokens.get(END_POSITION_INDEX)));
+    }
+
+    private static Position toPosition(String token) {
+        Column column = Column.toColumn(token.charAt(COL_POSITION_INDEX));
+        Row row = Row.toRow(token.charAt(ROW_POSITION_INDEX));
+        return new Position(column, row);
+    }
+
+    private static void validateInput(String input) {
+        Matcher matcher = POSITION_PATTERN.matcher(input);
+        if (!matcher.matches()) {
+            throw new IllegalArgumentException("[ERROR] 좌표 형식이 틀렸습니다.");
+        }
+    }
+
+    public Position from() {
+        return start;
+    }
+
+    public Position to() {
+        return end;
+    }
+}
diff --git a/src/main/java/domain/state/GamePhase.java b/src/main/java/domain/state/GamePhase.java
new file mode 100644
index 0000000000..8a7b71619c
--- /dev/null
+++ b/src/main/java/domain/state/GamePhase.java
@@ -0,0 +1,6 @@
+package domain.state;
+
+public enum GamePhase {
+    READY,
+    PLAYING
+}
diff --git a/src/main/java/domain/state/GameState.java b/src/main/java/domain/state/GameState.java
new file mode 100644
index 0000000000..ecab7d8b2c
--- /dev/null
+++ b/src/main/java/domain/state/GameState.java
@@ -0,0 +1,11 @@
+package domain.state;
+
+import domain.game.JanggiGame;
+import domain.setup.Command;
+
+public interface GameState {
+    GamePhase phase();
+
+    GameState handle(JanggiGame game, Command command);
+
+}
diff --git a/src/main/java/domain/state/PlayingState.java b/src/main/java/domain/state/PlayingState.java
new file mode 100644
index 0000000000..175e0afd84
--- /dev/null
+++ b/src/main/java/domain/state/PlayingState.java
@@ -0,0 +1,18 @@
+package domain.state;
+
+import domain.game.JanggiGame;
+import domain.setup.Command;
+
+public class PlayingState implements GameState {
+    @Override
+    public GameState handle(JanggiGame game, Command command) {
+        game.move(command.toCoordinate());
+        game.nextTurn();
+        return this;
+    }
+
+    @Override
+    public GamePhase phase() {
+        return GamePhase.PLAYING;
+    }
+}
diff --git a/src/main/java/domain/state/ReadyState.java b/src/main/java/domain/state/ReadyState.java
new file mode 100644
index 0000000000..b11c4e7db4
--- /dev/null
+++ b/src/main/java/domain/state/ReadyState.java
@@ -0,0 +1,34 @@
+package domain.state;
+
+import domain.game.JanggiGame;
+import domain.piece.Team;
+import domain.setup.Arrangement;
+import domain.setup.Arrangements;
+import domain.setup.Command;
+
+public class ReadyState implements GameState {
+    private final Arrangements arrangements;
+
+    public ReadyState(Arrangements arrangements) {
+        this.arrangements = arrangements;
+    }
+
+    @Override
+    public GameState handle(JanggiGame game, Command command) {
+        Arrangement arrangement = command.toArrangement();
+
+        if (!arrangements.hasArrangementFor(Team.HAN)) {
+            Arrangements nextArrangements = arrangements.assignArrangement(Team.HAN, arrangement);
+            game.nextTurn();
+            return new ReadyState(nextArrangements);
+        }
+
+        game.setupBoard(arrangements.assignArrangement(Team.CHO, arrangement));
+        return new PlayingState();
+    }
+
+    @Override
+    public GamePhase phase() {
+        return GamePhase.READY;
+    }
+}
diff --git a/src/main/java/io/GameConsole.java b/src/main/java/io/GameConsole.java
new file mode 100644
index 0000000000..0813e0c08c
--- /dev/null
+++ b/src/main/java/io/GameConsole.java
@@ -0,0 +1,54 @@
+package io;
+
+import domain.game.JanggiGame;
+
+public class GameConsole {
+    private final OutputView outputView;
+    private final InputView inputView;
+    private final JanggiGame janggiGame;
+
+    public GameConsole() {
+        this.outputView = new OutputView();
+        this.inputView = new InputView();
+        this.janggiGame = new JanggiGame();
+    }
+
+    public void run() {
+        while (true) {
+            retryUntilSuccess(() -> {
+                displayRequestCommand();
+                janggiGame.processCommand(inputView.readCommand());
+            });
+        }
+    }
+
+    public void displayRequestCommand() {
+        if (janggiGame.isReadyPhase()) {
+            outputView.printSetupTable(janggiGame.getTurn());
+        }
+        if (janggiGame.isPlayingPhase()) {
+            outputView.printBoard(janggiGame.getBoard(), janggiGame.getTurn());
+            outputView.printPieceMovement(janggiGame.getTurn());
+        }
+    }
+
+
+    private void retryUntilSuccess(Runnable action) {
+        boolean isSuccess = false;
+
+        while (!isSuccess) {
+            isSuccess = attempt(action);
+        }
+    }
+
+    private boolean attempt(Runnable action) {
+        try {
+            action.run();
+            return true;
+        } catch (IllegalArgumentException exception) {
+            outputView.printErrorMessage(exception.getMessage());
+            return false;
+        }
+    }
+
+}
diff --git a/src/main/java/io/InputView.java b/src/main/java/io/InputView.java
new file mode 100644
index 0000000000..b9b7f195be
--- /dev/null
+++ b/src/main/java/io/InputView.java
@@ -0,0 +1,21 @@
+package io;
+
+import domain.setup.Command;
+import domain.game.Turn;
+import java.util.Scanner;
+
+public class InputView {
+    private final Scanner scanner = new Scanner(System.in);
+
+    public Command readCommand() {
+        String input = validate(scanner.nextLine().trim());
+        return new Command(input);
+    }
+
+    private String validate(String input) {
+        if (input.isEmpty()) {
+            throw new IllegalArgumentException("[ERROR] 빈 입력은 허용되지 않습니다.");
+        }
+        return input;
+    }
+}
diff --git a/src/main/java/io/OutputView.java b/src/main/java/io/OutputView.java
new file mode 100644
index 0000000000..92bab1dd83
--- /dev/null
+++ b/src/main/java/io/OutputView.java
@@ -0,0 +1,71 @@
+package io;
+
+import domain.board.Board;
+import domain.board.Column;
+import domain.board.Position;
+import domain.game.Turn;
+import domain.board.Row;
+
+public class OutputView {
+    public static final String RED = "\u001B[31m";
+    public static final String GREEN = "\u001B[32m";
+    public static final String RESET = "\u001B[0m";
+    private static final String REQUEST_SETUP = """
+            [%s 진영] 배치를 선택하세요.
+            1. 마-상-마-상 (Horse-Elephant-Horse-Elephant)
+            2. 마-상-상-마 (Horse-Elephant-Elephant-Horse)
+            3. 상-마-마-상 (Elephant-Horse-Horse-Elephant)
+            4. 상-마-상-마 (Elephant-Horse-Elephant-Horse)""";
+    private static final String REQUEST_MOVE = "[%s 진영] {출발 좌표} {도착 좌표} 형식으로 입력해 수를 두세요. (ex. e6 e5)";
+
+    public void printSetupTable(Turn turn) {
+        String message = String.format(REQUEST_SETUP, turn.display());
+        System.out.println(message);
+    }
+
+    public void printErrorMessage(String message) {
+        System.out.println(message);
+    }
+
+    public void printBoard(Board board, Turn turn) {
+        StringBuilder stringBuilder = new StringBuilder();
+        appendHeader(stringBuilder, turn);
+        appendRows(stringBuilder, board);
+        System.out.println(stringBuilder);
+    }
+
+    private void appendHeader(StringBuilder stringBuilder, Turn turn) {
+        stringBuilder.append("--------------------------------------\n");
+        stringBuilder.append("현재 턴: [").append(turn.colorCode(RED, GREEN)).append(turn.display()).append(RESET)
+                .append(" 진영]\n\n");
+        stringBuilder.append("     a   b   c   d   e   f   g   h   i\n");
+    }
+
+    private void appendRows(StringBuilder stringBuilder, Board board) {
+        for (Row row : Row.values()) {
+            appendRow(stringBuilder, board, row);
+        }
+    }
+
+    private void appendRow(StringBuilder stringBuilder, Board board, Row row) {
+        stringBuilder.append(String.format("%2s  ", row.display()));
+        for (Column column : Column.values()) {
+            appendCell(stringBuilder, board, new Position(column, row));
+        }
+        stringBuilder.append("\n");
+    }
+
+    private void appendCell(StringBuilder stringBuilder, Board board, Position position) {
+        stringBuilder.append(cellDisplay(board, position)).append(" ");
+    }
+
+    private String cellDisplay(Board board, Position position) {
+        return board.pieceAt(position)
+                .map(piece -> piece.colorCode(RED, GREEN) + piece.display() + RESET)
+                .orElse("...");
+    }
+
+    public void printPieceMovement(Turn turn) {
+        System.out.printf((REQUEST_MOVE) + "%n", turn.display());
+    }
+}
diff --git a/src/test/java/domain/board/BoardTest.java b/src/test/java/domain/board/BoardTest.java
new file mode 100644
index 0000000000..c2113e9a84
--- /dev/null
+++ b/src/test/java/domain/board/BoardTest.java
@@ -0,0 +1,122 @@
+package domain.board;
+
+import domain.game.Turn;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.piece.Team;
+import domain.setup.Arrangement;
+import domain.setup.Arrangements;
+import domain.setup.Coordinate;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("Board 클래스 테스트")
+class BoardTest {
+
+    private Board initialBoard;
+    private Turn hanTurn;
+    private Turn choTurn;
+
+    @BeforeEach
+    void setUp() {
+        Arrangements arrangements = new Arrangements()
+                .assignArrangement(Team.HAN, Arrangement.MASANGMASANG)
+                .assignArrangement(Team.CHO, Arrangement.MASANGMASANG);
+        initialBoard = Board.of(arrangements);
+        hanTurn = new Turn(Team.HAN);
+        choTurn = new Turn(Team.CHO);
+    }
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    private Coordinate coord(String input) {
+        return Coordinate.toCoordinate(input);
+    }
+
+    @Test
+    @DisplayName("pieceAt: 기물이 있는 위치에서 해당 기물을 반환한다")
+    void pieceAtReturnsExistingPiece() {
+        Piece piece = initialBoard.pieceAt(pos(Column.A, Row.ZERO)).orElseThrow();
+
+        assertThat(piece).isNotNull();
+        assertThat(piece.isChariot()).isTrue();
+        assertThat(piece.isOwnedBy(Team.HAN)).isTrue();
+    }
+
+    @Test
+    @DisplayName("isEmpty: 빈 위치에서 true를 반환한다")
+    void isEmptyReturnsTrueForEmptyPosition() {
+        assertThat(initialBoard.isEmpty(pos(Column.A, Row.FOUR))).isTrue();
+        assertThat(initialBoard.isEmpty(pos(Column.E, Row.FIVE))).isTrue();
+    }
+
+    @Test
+    @DisplayName("isEmpty: 기물 있는 위치에서 false를 반환한다")
+    void isEmptyReturnsFalseForOccupiedPosition() {
+        assertThat(initialBoard.isEmpty(pos(Column.A, Row.ZERO))).isFalse();
+        assertThat(initialBoard.isEmpty(pos(Column.E, Row.ONE))).isFalse();
+    }
+
+    @Test
+    @DisplayName("hasAnyPiece: 기물 있는 위치에서 true를 반환한다")
+    void hasAnyPieceReturnsTrueForOccupiedPosition() {
+        assertThat(initialBoard.hasAnyPiece(pos(Column.A, Row.ZERO))).isTrue();
+    }
+
+    @Test
+    @DisplayName("hasAnyPiece: 해당 위치에 기물이 없으면 false를 반환한다")
+    void hasAnyPieceReturnsFalseForEmptyPosition() {
+        assertThat(initialBoard.hasAnyPiece(pos(Column.A, Row.FOUR))).isFalse();
+    }
+
+    @Test
+    @DisplayName("hasFriendOf: 같은 팀 기물이 있으면 true를 반환한다")
+    void hasFriendOfReturnsTrueForSameTeamPiece() {
+        Piece hanChariot = new Piece(Team.HAN, PieceType.CHARIOT);
+        assertThat(initialBoard.hasFriendOf(pos(Column.D, Row.ZERO), hanChariot)).isTrue();
+    }
+
+    @Test
+    @DisplayName("hasFriendOf: 다른 팀 기물이 있으면 false를 반환한다")
+    void hasFriendOfReturnsFalseForEnemyPiece() {
+        Piece hanChariot = new Piece(Team.HAN, PieceType.CHARIOT);
+        assertThat(initialBoard.hasFriendOf(pos(Column.A, Row.NINE), hanChariot)).isFalse();
+    }
+
+    @Test
+    @DisplayName("hasEnemyOf: 다른 팀 기물이 있으면 true를 반환한다")
+    void hasEnemyOfReturnsTrueForEnemyPiece() {
+        Piece hanChariot = new Piece(Team.HAN, PieceType.CHARIOT);
+        assertThat(initialBoard.hasEnemyOf(pos(Column.A, Row.NINE), hanChariot)).isTrue();
+    }
+
+    @Test
+    @DisplayName("hasEnemyOf: 같은 팀 기물이 있으면 false를 반환한다")
+    void hasEnemyOfReturnsFalseForSameTeamPiece() {
+        Piece hanChariot = new Piece(Team.HAN, PieceType.CHARIOT);
+        assertThat(initialBoard.hasEnemyOf(pos(Column.D, Row.ZERO), hanChariot)).isFalse();
+    }
+
+    @Test
+    @DisplayName("move: 출발 좌표에 이동 가능한 기물이 없을 시 예외를 던진다")
+    void moveFromEmptyPositionThrowsException() {
+        assertThatThrownBy(() -> initialBoard.move(coord("a4 a5"), hanTurn))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("[ERROR]");
+    }
+
+    @Test
+    @DisplayName("move: 상대 팀 기물 이동 시도 시 예외를 던진다")
+    void moveOpponentPieceThrowsException() {
+        assertThatThrownBy(() -> initialBoard.move(coord("a9 a8"), hanTurn))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("[ERROR]");
+    }
+
+}
diff --git a/src/test/java/domain/board/ColumnTest.java b/src/test/java/domain/board/ColumnTest.java
new file mode 100644
index 0000000000..834aaa2881
--- /dev/null
+++ b/src/test/java/domain/board/ColumnTest.java
@@ -0,0 +1,38 @@
+package domain.board;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("Col 열거형 테스트")
+class ColumnTest {
+
+    @Test
+    @DisplayName("toCol: 소문자 a-i를 올바른 Col로 변환한다")
+    void toColumnConvertsLowercaseChar() {
+        assertThat(Column.toColumn('a')).isEqualTo(Column.A);
+        assertThat(Column.toColumn('e')).isEqualTo(Column.E);
+        assertThat(Column.toColumn('i')).isEqualTo(Column.I);
+    }
+
+    @Test
+    @DisplayName("toCol: 대문자 A-I를 올바른 Col로 변환한다")
+    void toColumnConvertsUppercaseChar() {
+        assertThat(Column.toColumn('A')).isEqualTo(Column.A);
+        assertThat(Column.toColumn('E')).isEqualTo(Column.E);
+        assertThat(Column.toColumn('I')).isEqualTo(Column.I);
+    }
+
+    @Test
+    @DisplayName("toCol: 유효하지 않은 col은 예외를 던진다")
+    void toColumnThrowsForInvalidChar() {
+        assertThatThrownBy(() -> Column.toColumn('j'))
+                .isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> Column.toColumn('z'))
+                .isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> Column.toColumn('J'))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}
diff --git a/src/test/java/domain/board/PiecesTest.java b/src/test/java/domain/board/PiecesTest.java
new file mode 100644
index 0000000000..6b86017e34
--- /dev/null
+++ b/src/test/java/domain/board/PiecesTest.java
@@ -0,0 +1,81 @@
+package domain.board;
+
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.piece.Team;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("Pieces 클래스 테스트")
+class PiecesTest {
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    private Piece hanChariot() {
+        return new Piece(Team.HAN, PieceType.CHARIOT);
+    }
+
+    private Piece choSoldier() {
+        return new Piece(Team.CHO, PieceType.SOLDIER);
+    }
+
+    private Pieces piecesWithHanChariotAtA0() {
+        Map<Position, Piece> map = new HashMap<>();
+        map.put(pos(Column.A, Row.ZERO), hanChariot());
+        return new Pieces(map);
+    }
+
+    @Test
+    @DisplayName("move: 기물을 from에서 to로 정상 이동한다")
+    void moveReturnsPiecesWithMovedPiece() {
+        Pieces pieces = piecesWithHanChariotAtA0();
+        Position from = pos(Column.A, Row.ZERO);
+        Position to = pos(Column.A, Row.FIVE);
+
+        Pieces moved = pieces.move(from, to);
+
+        assertThat(moved.at(from)).isEmpty();
+        Piece movedPiece = moved.at(to).orElseThrow();
+        assertThat(movedPiece).isNotNull();
+        assertThat(movedPiece.isChariot()).isTrue();
+        assertThat(movedPiece.isOwnedBy(Team.HAN)).isTrue();
+    }
+
+    @Test
+    @DisplayName("move: 적 기물이 있는 위치로 이동하면 적 기물을 제거한다 (잡기)")
+    void moveCapturingEnemyPieceReplacesIt() {
+        Map<Position, Piece> map = new HashMap<>();
+        Position from = pos(Column.A, Row.ZERO);
+        Position to = pos(Column.A, Row.FIVE);
+        map.put(from, hanChariot());
+        map.put(to, choSoldier());
+        Pieces pieces = new Pieces(map);
+
+        Pieces moved = pieces.move(from, to);
+
+        assertThat(moved.at(from)).isEmpty();
+        Piece movedPiece = moved.at(to).orElseThrow();
+        assertThat(movedPiece).isNotNull();
+        assertThat(movedPiece.isChariot()).isTrue();
+        assertThat(movedPiece.isOwnedBy(Team.HAN)).isTrue();
+    }
+
+    @Test
+    @DisplayName("move: 기물 없는 위치에서 이동 시 예외를 던진다")
+    void moveFromEmptyPositionThrowsException() {
+        Pieces pieces = piecesWithHanChariotAtA0();
+        Position empty = pos(Column.C, Row.FIVE);
+
+        assertThatThrownBy(() -> pieces.move(empty, pos(Column.C, Row.SIX)))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("[ERROR]");
+    }
+}
diff --git a/src/test/java/domain/board/PositionTest.java b/src/test/java/domain/board/PositionTest.java
new file mode 100644
index 0000000000..4c5a204edc
--- /dev/null
+++ b/src/test/java/domain/board/PositionTest.java
@@ -0,0 +1,64 @@
+package domain.board;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import domain.movement.ColumnDelta;
+import domain.movement.Delta;
+import domain.movement.RowDelta;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("Position 레코드 테스트")
+class PositionTest {
+
+    private Delta delta(int col, int row) {
+        return new Delta(new ColumnDelta(col), new RowDelta(row));
+    }
+
+    @Test
+    @DisplayName("동일한 col과 row를 가진 Position은 동등하다")
+    void positionsWithSameColAndRowAreEqual() {
+        Position pos1 = new Position(Column.E, Row.FOUR);
+        Position pos2 = new Position(Column.E, Row.FOUR);
+
+        assertThat(pos1).isEqualTo(pos2);
+        assertThat(pos1.hashCode()).isEqualTo(pos2.hashCode());
+    }
+
+    @Test
+    @DisplayName("canShift: 보드 내 이동 가능한 delta는 true를 반환한다")
+    void canShiftReturnsTrueForValidDelta() {
+        Position center = new Position(Column.E, Row.FOUR);
+
+        assertThat(center.canShift(delta(0, 1))).isTrue();
+        assertThat(center.canShift(delta(0, -1))).isTrue();
+        assertThat(center.canShift(delta(1, 0))).isTrue();
+        assertThat(center.canShift(delta(-1, 0))).isTrue();
+        assertThat(center.canShift(delta(3, 3))).isTrue();
+        assertThat(center.canShift(delta(-3, -3))).isTrue();
+    }
+
+    @Test
+    @DisplayName("canShift: 보드 밖으로 나가는 delta는 false를 반환한다")
+    void canShiftReturnsFalseWhenOutOfBounds() {
+        Position topLeft = new Position(Column.A, Row.ZERO);
+        Position bottomRight = new Position(Column.I, Row.NINE);
+
+        assertThat(topLeft.canShift(delta(-1, 0))).isFalse();
+        assertThat(topLeft.canShift(delta(0, -1))).isFalse();
+        assertThat(bottomRight.canShift(delta(1, 0))).isFalse();
+        assertThat(bottomRight.canShift(delta(0, 1))).isFalse();
+    }
+
+    @Test
+    @DisplayName("shift: delta만큼 이동한 새로운 Position을 반환한다")
+    void shiftReturnsNewPositionWithAppliedDelta() {
+        Position pos = new Position(Column.C, Row.THREE);
+
+        assertThat(pos.shift(delta(1, 0))).isEqualTo(new Position(Column.D, Row.THREE));
+        assertThat(pos.shift(delta(-1, 0))).isEqualTo(new Position(Column.B, Row.THREE));
+        assertThat(pos.shift(delta(0, 1))).isEqualTo(new Position(Column.C, Row.FOUR));
+        assertThat(pos.shift(delta(0, -1))).isEqualTo(new Position(Column.C, Row.TWO));
+        assertThat(pos.shift(delta(2, 3))).isEqualTo(new Position(Column.E, Row.SIX));
+    }
+}
diff --git a/src/test/java/domain/board/RowTest.java b/src/test/java/domain/board/RowTest.java
new file mode 100644
index 0000000000..3754072383
--- /dev/null
+++ b/src/test/java/domain/board/RowTest.java
@@ -0,0 +1,44 @@
+package domain.board;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("Row 열거형 테스트")
+class RowTest {
+
+    @Test
+    @DisplayName("reverse: ZERO <-> NINE, ONE <-> EIGHT 등 대칭적으로 뒤집는다")
+    void reverseReturnsSymmetricRow() {
+        assertThat(Row.ZERO.reverse()).isEqualTo(Row.NINE);
+        assertThat(Row.NINE.reverse()).isEqualTo(Row.ZERO);
+        assertThat(Row.ONE.reverse()).isEqualTo(Row.EIGHT);
+        assertThat(Row.FOUR.reverse()).isEqualTo(Row.FIVE);
+        assertThat(Row.FIVE.reverse()).isEqualTo(Row.FOUR);
+    }
+
+    @Test
+    @DisplayName("toRow: 유효한 숫자 문자를 올바른 Row로 변환한다")
+    void toRowConvertsValidChar() {
+        assertThat(Row.toRow('0')).isEqualTo(Row.ZERO);
+        assertThat(Row.toRow('1')).isEqualTo(Row.ONE);
+        assertThat(Row.toRow('9')).isEqualTo(Row.NINE);
+        assertThat(Row.toRow('5')).isEqualTo(Row.FIVE);
+    }
+
+    @Test
+    @DisplayName("toRow: 유효하지 않은 문자는 예외를 던진다")
+    void toRowThrowsForInvalidChar() {
+        assertThatThrownBy(() -> Row.toRow('a'))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("[ERROR]");
+        assertThatThrownBy(() -> Row.toRow(' '))
+                .isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> Row.toRow('!'))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}
diff --git a/src/test/java/domain/game/JanggiGameTest.java b/src/test/java/domain/game/JanggiGameTest.java
new file mode 100644
index 0000000000..3f2e237c5b
--- /dev/null
+++ b/src/test/java/domain/game/JanggiGameTest.java
@@ -0,0 +1,63 @@
+package domain.game;
+
+import domain.piece.Team;
+import domain.setup.Command;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("JanggiGame 클래스 테스트")
+class JanggiGameTest {
+
+    @Test
+    @DisplayName("초기화 시 HAN 팀의 턴으로 시작한다")
+    void initialTurnIsHan() {
+        JanggiGame game = new JanggiGame();
+
+        assertThat(game.getTurn().display()).isEqualTo(Team.HAN.display());
+    }
+
+    @Test
+    @DisplayName("HAN 상차림 배치 입력 후 CHO 상차림을 진행한다")
+    void afterHanSetupTurnChangesToCho() {
+        JanggiGame game = new JanggiGame();
+
+        game.processCommand(new Command("1"));
+
+        assertThat(game.getTurn().display()).isEqualTo(Team.CHO.display());
+    }
+
+    @Test
+    @DisplayName("기물 정상 이동 후 턴이 상대 팀으로 바뀐다")
+    void turnChangesAfterMove() {
+        JanggiGame game = new JanggiGame();
+        game.processCommand(new Command("1"));
+        game.processCommand(new Command("1"));
+
+        game.processCommand(new Command("e6 e5"));
+
+        assertThat(game.getTurn().display()).isEqualTo(Team.HAN.display());
+    }
+
+    @Test
+    @DisplayName("설정 단계에서 유효하지 않은 배치 코드는 예외를 던진다")
+    void invalidArrangementCommandThrowsException() {
+        JanggiGame game = new JanggiGame();
+
+        assertThatThrownBy(() -> game.processCommand(new Command("5")))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    @DisplayName("플레이 단계에서 잘못된 좌표는 예외를 던진다")
+    void invalidCoordinateInPlayingStateThrowsException() {
+        JanggiGame game = new JanggiGame();
+        game.processCommand(new Command("1"));
+        game.processCommand(new Command("1")); // now in playing state, CHO's turn
+
+        assertThatThrownBy(() -> game.processCommand(new Command("z0 a1")))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}
diff --git a/src/test/java/domain/game/TurnTest.java b/src/test/java/domain/game/TurnTest.java
new file mode 100644
index 0000000000..f778b5632f
--- /dev/null
+++ b/src/test/java/domain/game/TurnTest.java
@@ -0,0 +1,51 @@
+package domain.game;
+
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.piece.Team;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("Turn 클래스 테스트")
+class TurnTest {
+
+    @Test
+    @DisplayName("belongsTo: 현재 팀의 기물에는 true를 반환한다")
+    void belongsToReturnsTrueForCurrentTeamPiece() {
+        Turn hanTurn = new Turn(Team.HAN);
+        Piece hanPiece = new Piece(Team.HAN, PieceType.SOLDIER);
+
+        assertThat(hanTurn.belongsTo(hanPiece)).isTrue();
+    }
+
+    @Test
+    @DisplayName("belongsTo: 상대 팀의 기물에는 false를 반환한다")
+    void belongsToReturnsFalseForOpponentPiece() {
+        Turn hanTurn = new Turn(Team.HAN);
+        Piece choPiece = new Piece(Team.CHO, PieceType.SOLDIER);
+
+        assertThat(hanTurn.belongsTo(choPiece)).isFalse();
+    }
+
+    @Test
+    @DisplayName("changeTeam: HAN 팀 턴에서 changeTeam 하면 CHO 팀 턴이 된다")
+    void hanTurnChangesToCho() {
+        Turn hanTurn = new Turn(Team.HAN);
+
+        Turn next = hanTurn.changeTeam();
+
+        assertThat(next.display()).isEqualTo(Team.CHO.display());
+    }
+
+    @Test
+    @DisplayName("changeTeam: CHO 팀 턴에서 changeTeam 하면 HAN 팀 턴이 된다")
+    void choTurnChangesToHan() {
+        Turn choTurn = new Turn(Team.CHO);
+
+        Turn next = choTurn.changeTeam();
+
+        assertThat(next.display()).isEqualTo(Team.HAN.display());
+    }
+}
diff --git a/src/test/java/domain/movement/ChariotOrCannonMovementTest.java b/src/test/java/domain/movement/ChariotOrCannonMovementTest.java
new file mode 100644
index 0000000000..87bc2d905d
--- /dev/null
+++ b/src/test/java/domain/movement/ChariotOrCannonMovementTest.java
@@ -0,0 +1,89 @@
+package domain.movement;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import domain.board.Column;
+import domain.board.Position;
+import domain.board.Row;
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("LinearMovement 클래스 테스트")
+class ChariotOrCannonMovementTest {
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    @Test
+    @DisplayName("기물이 보드 중앙에 위치한다 가정, 후보 경로를 정상적으로 생성한다")
+    void fromCenterCreatesFourLinearPaths() {
+        ChariotOrCannonMovement movement = new ChariotOrCannonMovement();
+        Position center = pos(Column.E, Row.FOUR);
+
+        Paths paths = movement.candidatePaths(center);
+
+        assertThat(paths.asList()).hasSize(4);
+    }
+
+    @Test
+    @DisplayName("각 경로는 보드 경계까지로 구성된다")
+    void eachPathExtendsToEdge() {
+        ChariotOrCannonMovement movement = new ChariotOrCannonMovement();
+        Position center = pos(Column.E, Row.FOUR);
+
+        Paths paths = movement.candidatePaths(center);
+
+        Path upPath = paths.asList().stream()
+                .filter(p -> p.endsAt(pos(Column.E, Row.ZERO)))
+                .findFirst()
+                .orElse(null);
+        assertThat(upPath).isNotNull();
+
+        Path downPath = paths.asList().stream()
+                .filter(p -> p.endsAt(pos(Column.E, Row.NINE)))
+                .findFirst()
+                .orElse(null);
+        assertThat(downPath).isNotNull();
+    }
+
+    @Test
+    @DisplayName("위 방향 경로는 모든 중간 위치를 포함한다")
+    void upPathContainsAllIntermediatePositions() {
+        ChariotOrCannonMovement movement = new ChariotOrCannonMovement();
+        Position start = pos(Column.E, Row.FOUR);
+
+        Paths paths = movement.candidatePaths(start);
+
+        Path upPath = paths.asList().stream()
+                .filter(p -> p.endsAt(pos(Column.E, Row.ZERO)))
+                .findFirst()
+                .orElseThrow();
+
+        List<Position> intermediates = upPath.intermediates();
+        assertThat(intermediates).containsExactly(
+                pos(Column.E, Row.THREE),
+                pos(Column.E, Row.TWO),
+                pos(Column.E, Row.ONE)
+        );
+    }
+
+    @Test
+    @DisplayName("경로 내 중간 위치들이 순서대로 정렬된다")
+    void pathIntermediatesAreOrdered() {
+        ChariotOrCannonMovement movement = new ChariotOrCannonMovement();
+        Position start = pos(Column.A, Row.ZERO);
+
+        Paths paths = movement.candidatePaths(start);
+
+        Path downPath = paths.asList().stream()
+                .filter(p -> p.endsAt(pos(Column.A, Row.NINE)))
+                .findFirst()
+                .orElseThrow();
+
+        List<Position> intermediates = downPath.intermediates();
+        assertThat(intermediates.get(0)).isEqualTo(pos(Column.A, Row.ONE));
+        assertThat(intermediates.get(7)).isEqualTo(pos(Column.A, Row.EIGHT));
+    }
+}
diff --git a/src/test/java/domain/movement/ElephantMovementTest.java b/src/test/java/domain/movement/ElephantMovementTest.java
new file mode 100644
index 0000000000..0b7623085b
--- /dev/null
+++ b/src/test/java/domain/movement/ElephantMovementTest.java
@@ -0,0 +1,63 @@
+package domain.movement;
+
+import domain.board.Column;
+import domain.board.Position;
+import domain.board.Row;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("ElephantMovement 클래스 테스트")
+class ElephantMovementTest {
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    private boolean canReach(Paths paths, Position target) {
+        return paths.asList().stream().anyMatch(p -> p.endsAt(target));
+    }
+
+    @Test
+    @DisplayName("기물이 보드 중앙에 위치한다 가정, 후보 경로를 정상적으로 생성한다")
+    void fromCenterReachablePositionsAreCorrect() {
+        ElephantMovement movement = new ElephantMovement();
+        Position center = pos(Column.E, Row.FOUR);
+
+        Paths paths = movement.candidatePaths(center);
+
+        assertThat(canReach(paths, pos(Column.C, Row.ONE))).isTrue();
+        assertThat(canReach(paths, pos(Column.G, Row.ONE))).isTrue();
+        assertThat(canReach(paths, pos(Column.C, Row.SEVEN))).isTrue();
+        assertThat(canReach(paths, pos(Column.G, Row.SEVEN))).isTrue();
+        assertThat(canReach(paths, pos(Column.B, Row.TWO))).isTrue();
+        assertThat(canReach(paths, pos(Column.B, Row.SIX))).isTrue();
+        assertThat(canReach(paths, pos(Column.H, Row.TWO))).isTrue();
+        assertThat(canReach(paths, pos(Column.H, Row.SIX))).isTrue();
+    }
+
+    @Test
+    @DisplayName("보드 범위를 벗어나는 경로를 제외하고, 후보 경로를 정상적으로 생성한다")
+    void fromCornerHasTwoPaths() {
+        ElephantMovement movement = new ElephantMovement();
+        Position corner = pos(Column.A, Row.ZERO);
+
+        Paths paths = movement.candidatePaths(corner);
+
+        assertThat(paths.asList()).hasSize(2);
+        assertThat(canReach(paths, pos(Column.C, Row.THREE))).isTrue();
+        assertThat(canReach(paths, pos(Column.D, Row.TWO))).isTrue();
+    }
+
+    @Test
+    @DisplayName("상의 각 이동 경로는 3개의 좌표를 갖는다")
+    void eachPathHasThreePositions() {
+        ElephantMovement movement = new ElephantMovement();
+        Paths paths = movement.candidatePaths(pos(Column.E, Row.FOUR));
+
+        paths.asList().forEach(path ->
+                assertThat(path.intermediates()).hasSize(2)
+        );
+    }
+}
diff --git a/src/test/java/domain/movement/GeneralMovementTest.java b/src/test/java/domain/movement/GeneralMovementTest.java
new file mode 100644
index 0000000000..0bf208a4d2
--- /dev/null
+++ b/src/test/java/domain/movement/GeneralMovementTest.java
@@ -0,0 +1,60 @@
+package domain.movement;
+
+import domain.board.Column;
+import domain.board.Position;
+import domain.board.Row;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("GeneralMovement 클래스 테스트")
+class GeneralMovementTest {
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    private boolean canReach(Paths paths, Position target) {
+        return paths.asList().stream().anyMatch(p -> p.endsAt(target));
+    }
+
+    @Test
+    @DisplayName("기물이 보드 중앙에 위치한다 가정, 후보 경로를 정상적으로 생성한다")
+    void fromCenterHasFourCandidatePaths() {
+        GeneralMovement movement = new GeneralMovement();
+        Position center = pos(Column.E, Row.FOUR);
+
+        Paths paths = movement.candidatePaths(center);
+
+        assertThat(paths.asList()).hasSize(4);
+        assertThat(canReach(paths, pos(Column.E, Row.THREE))).isTrue();
+        assertThat(canReach(paths, pos(Column.E, Row.FIVE))).isTrue();
+        assertThat(canReach(paths, pos(Column.D, Row.FOUR))).isTrue();
+        assertThat(canReach(paths, pos(Column.F, Row.FOUR))).isTrue();
+    }
+
+    @Test
+    @DisplayName("보드 범위를 벗어나는 경로를 제외하고, 후보 경로를 정상적으로 생성한다")
+    void fromTopLeftCornerHasTwoPaths() {
+        GeneralMovement movement = new GeneralMovement();
+        Position topLeft = pos(Column.A, Row.ZERO);
+
+        Paths paths = movement.candidatePaths(topLeft);
+
+        assertThat(paths.asList()).hasSize(2);
+        assertThat(canReach(paths, pos(Column.A, Row.ONE))).isTrue();  // down
+        assertThat(canReach(paths, pos(Column.B, Row.ZERO))).isTrue(); // right
+    }
+
+    @Test
+    @DisplayName("궁의 각 이동 경로는 1개의 좌표를 갖는다")
+    void eachCandidatePathHasOnePosition() {
+        GeneralMovement movement = new GeneralMovement();
+        Paths paths = movement.candidatePaths(pos(Column.E, Row.FOUR));
+
+        paths.asList().forEach(path ->
+                assertThat(path.intermediates()).isEmpty()
+        );
+    }
+}
diff --git a/src/test/java/domain/movement/GuardMovementTest.java b/src/test/java/domain/movement/GuardMovementTest.java
new file mode 100644
index 0000000000..a673087db2
--- /dev/null
+++ b/src/test/java/domain/movement/GuardMovementTest.java
@@ -0,0 +1,46 @@
+package domain.movement;
+
+import domain.board.Column;
+import domain.board.Position;
+import domain.board.Row;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("GuardMovement 클래스 테스트")
+class GuardMovementTest {
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    private boolean canReach(Paths paths, Position target) {
+        return paths.asList().stream().anyMatch(p -> p.endsAt(target));
+    }
+
+    @Test
+    @DisplayName("기물이 보드 중앙에 위치한다 가정, 후보 경로를 정상적으로 생성한다")
+    void fromCenterHasFourCandidatePaths() {
+        GuardMovement movement = new GuardMovement();
+        Position center = pos(Column.E, Row.FOUR);
+
+        Paths paths = movement.candidatePaths(center);
+
+        assertThat(paths.asList()).hasSize(4);
+        assertThat(canReach(paths, pos(Column.E, Row.THREE))).isTrue();
+        assertThat(canReach(paths, pos(Column.E, Row.FIVE))).isTrue();
+        assertThat(canReach(paths, pos(Column.D, Row.FOUR))).isTrue();
+        assertThat(canReach(paths, pos(Column.F, Row.FOUR))).isTrue();
+    }
+
+    @Test
+    @DisplayName("보드 범위를 벗어나는 경로를 제외하고, 후보 경로를 정상적으로 생성한다")
+    void fromCornerHasTwoPaths() {
+        GuardMovement movement = new GuardMovement();
+
+        Paths paths = movement.candidatePaths(pos(Column.A, Row.ZERO));
+
+        assertThat(paths.asList()).hasSize(2);
+    }
+}
diff --git a/src/test/java/domain/movement/HorseMovementTest.java b/src/test/java/domain/movement/HorseMovementTest.java
new file mode 100644
index 0000000000..59bce00421
--- /dev/null
+++ b/src/test/java/domain/movement/HorseMovementTest.java
@@ -0,0 +1,63 @@
+package domain.movement;
+
+import domain.board.Column;
+import domain.board.Position;
+import domain.board.Row;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("HorseMovement 클래스 테스트")
+class HorseMovementTest {
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    private boolean canReach(Paths paths, Position target) {
+        return paths.asList().stream().anyMatch(p -> p.endsAt(target));
+    }
+
+    @Test
+    @DisplayName("기물이 보드 중앙에 위치한다 가정, 후보 경로를 정상적으로 생성한다")
+    void fromCenterReachablePositionsAreCorrect() {
+        HorseMovement movement = new HorseMovement();
+        Position center = pos(Column.E, Row.FOUR);
+
+        Paths paths = movement.candidatePaths(center);
+
+        assertThat(canReach(paths, pos(Column.D, Row.TWO))).isTrue();
+        assertThat(canReach(paths, pos(Column.F, Row.TWO))).isTrue();
+        assertThat(canReach(paths, pos(Column.D, Row.SIX))).isTrue();
+        assertThat(canReach(paths, pos(Column.F, Row.SIX))).isTrue();
+        assertThat(canReach(paths, pos(Column.C, Row.THREE))).isTrue();
+        assertThat(canReach(paths, pos(Column.C, Row.FIVE))).isTrue();
+        assertThat(canReach(paths, pos(Column.G, Row.THREE))).isTrue();
+        assertThat(canReach(paths, pos(Column.G, Row.FIVE))).isTrue();
+    }
+
+    @Test
+    @DisplayName("보드 범위를 벗어나는 경로를 제외하고, 후보 경로를 정상적으로 생성한다")
+    void fromCornerHasTwoPaths() {
+        HorseMovement movement = new HorseMovement();
+        Position corner = pos(Column.A, Row.ZERO);
+
+        Paths paths = movement.candidatePaths(corner);
+
+        assertThat(paths.asList()).hasSize(2);
+        assertThat(canReach(paths, pos(Column.B, Row.TWO))).isTrue();
+        assertThat(canReach(paths, pos(Column.C, Row.ONE))).isTrue();
+    }
+
+    @Test
+    @DisplayName("말의 각 이동 경로는 2개의 좌표를 갖는다")
+    void eachPathHasTwoPositions() {
+        HorseMovement movement = new HorseMovement();
+        Paths paths = movement.candidatePaths(pos(Column.E, Row.FOUR));
+
+        paths.asList().forEach(path -> {
+            assertThat(path.intermediates()).hasSize(1);
+        });
+    }
+}
diff --git a/src/test/java/domain/movement/MovementFactoryTest.java b/src/test/java/domain/movement/MovementFactoryTest.java
new file mode 100644
index 0000000000..4b8ee6dd8f
--- /dev/null
+++ b/src/test/java/domain/movement/MovementFactoryTest.java
@@ -0,0 +1,93 @@
+package domain.movement;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.piece.Team;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("MovementFactory 클래스 테스트")
+class MovementFactoryTest {
+
+    @Test
+    @DisplayName("GENERAL 기물은 GeneralMovement를 생성한다")
+    void createGeneralMovement() {
+        Piece piece = new Piece(Team.HAN, PieceType.GENERAL);
+
+        Movement movement = MovementFactory.create(piece);
+
+        assertThat(movement).isInstanceOf(GeneralMovement.class);
+    }
+
+    @Test
+    @DisplayName("GUARD 기물은 GuardMovement를 생성한다")
+    void createGuardMovement() {
+        Piece piece = new Piece(Team.HAN, PieceType.GUARD);
+
+        Movement movement = MovementFactory.create(piece);
+
+        assertThat(movement).isInstanceOf(GuardMovement.class);
+    }
+
+    @Test
+    @DisplayName("CHARIOT 기물은 LinearMovement를 생성한다")
+    void createChariotMovement() {
+        Piece piece = new Piece(Team.HAN, PieceType.CHARIOT);
+
+        Movement movement = MovementFactory.create(piece);
+
+        assertThat(movement).isInstanceOf(ChariotOrCannonMovement.class);
+    }
+
+    @Test
+    @DisplayName("CANNON 기물은 LinearMovement를 생성한다")
+    void createCannonMovement() {
+        Piece piece = new Piece(Team.CHO, PieceType.CANNON);
+
+        Movement movement = MovementFactory.create(piece);
+
+        assertThat(movement).isInstanceOf(ChariotOrCannonMovement.class);
+    }
+
+    @Test
+    @DisplayName("HORSE 기물은 HorseMovement를 생성한다")
+    void createHorseMovement() {
+        Piece piece = new Piece(Team.HAN, PieceType.HORSE);
+
+        Movement movement = MovementFactory.create(piece);
+
+        assertThat(movement).isInstanceOf(HorseMovement.class);
+    }
+
+    @Test
+    @DisplayName("ELEPHANT 기물은 ElephantMovement를 생성한다")
+    void createElephantMovement() {
+        Piece piece = new Piece(Team.CHO, PieceType.ELEPHANT);
+
+        Movement movement = MovementFactory.create(piece);
+
+        assertThat(movement).isInstanceOf(ElephantMovement.class);
+    }
+
+    @Test
+    @DisplayName("HAN SOLDIER 기물은 SoldierMovement를 생성한다")
+    void createHanSoldierMovement() {
+        Piece piece = new Piece(Team.HAN, PieceType.SOLDIER);
+
+        Movement movement = MovementFactory.create(piece);
+
+        assertThat(movement).isInstanceOf(SoldierMovement.class);
+    }
+
+    @Test
+    @DisplayName("CHO SOLDIER 기물은 SoldierMovement를 생성한다")
+    void createChoSoldierMovement() {
+        Piece piece = new Piece(Team.CHO, PieceType.SOLDIER);
+
+        Movement movement = MovementFactory.create(piece);
+
+        assertThat(movement).isInstanceOf(SoldierMovement.class);
+    }
+}
diff --git a/src/test/java/domain/movement/MovementValidatorTest.java b/src/test/java/domain/movement/MovementValidatorTest.java
new file mode 100644
index 0000000000..16a3da2324
--- /dev/null
+++ b/src/test/java/domain/movement/MovementValidatorTest.java
@@ -0,0 +1,339 @@
+package domain.movement;
+
+import domain.board.Board;
+import domain.board.Column;
+import domain.board.Pieces;
+import domain.board.Position;
+import domain.board.Row;
+import domain.game.Turn;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+import domain.piece.Team;
+import domain.setup.Coordinate;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("MovementValidator 통합 테스트 (Board를 통한 검증)")
+class MovementValidatorTest {
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    private Board boardWith(Map<Position, Piece> pieceMap) {
+        return new Board(new Pieces(pieceMap));
+    }
+
+    private Coordinate coord(String input) {
+        return Coordinate.toCoordinate(input);
+    }
+
+    private Map<Position, Piece> pieces() {
+        return new HashMap<>();
+    }
+
+    @Nested
+    @DisplayName("차(CHARIOT) 이동 검증")
+    class ChariotMovementValidation {
+
+        @Test
+        @DisplayName("차는 빈 경로로 몇칸이든 이동 가능하다")
+        void chariotCanMoveAlongClearPath() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.A, Row.ZERO), new Piece(Team.HAN, PieceType.CHARIOT));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            Board moved = board.move(coord("a0 a9"), turn);
+
+            assertThat(moved.isEmpty(pos(Column.A, Row.ZERO))).isTrue();
+            assertThat(moved.pieceAt(pos(Column.A, Row.NINE))).isPresent();
+        }
+
+        @Test
+        @DisplayName("차는 아군 기물이 있는 위치로 이동할 수 없다")
+        void chariotCannotCaptureFriendlyPiece() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.A, Row.ZERO), new Piece(Team.HAN, PieceType.CHARIOT));
+            map.put(pos(Column.A, Row.FIVE), new Piece(Team.HAN, PieceType.SOLDIER));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("a0 a5"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("차는 경로 중간에 기물이 있으면 그 너머로 이동할 수 없다")
+        void chariotCannotMoveThroughAnyPiece() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.A, Row.ZERO), new Piece(Team.HAN, PieceType.CHARIOT));
+            map.put(pos(Column.A, Row.THREE), new Piece(Team.CHO, PieceType.SOLDIER));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("a0 a5"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("차는 후보 경로에 없는 위치로 이동할 수 없다")
+        void chariotCannotMoveDiagonally() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FOUR), new Piece(Team.HAN, PieceType.CHARIOT));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("e4 f5"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Nested
+    @DisplayName("포(CANNON) 이동 검증")
+    class CannonMovementValidation {
+
+        @Test
+        @DisplayName("포는 1개의 기물을 넘어서 빈 위치로 이동할 수 있다")
+        void cannonCanJumpOverOneNonCannonToEmptyCell() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.A, Row.ZERO), new Piece(Team.HAN, PieceType.CANNON));
+            map.put(pos(Column.A, Row.FOUR), new Piece(Team.CHO, PieceType.SOLDIER));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            Board moved = board.move(coord("a0 a7"), turn);
+
+            assertThat(moved.isEmpty(pos(Column.A, Row.ZERO))).isTrue();
+            assertThat(moved.pieceAt(pos(Column.A, Row.SEVEN))).isPresent();
+        }
+
+        @Test
+        @DisplayName("포는 뛰어넘을 기물이 없으면 이동할 수 없다")
+        void cannonCannotMoveWithoutJumpPiece() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.A, Row.ZERO), new Piece(Team.HAN, PieceType.CANNON));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("a0 a9"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("포는 2개 이상의 기물을 뛰어넘을 수 없다")
+        void cannonCannotJumpOverTwoPieces() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.A, Row.ZERO), new Piece(Team.HAN, PieceType.CANNON));
+            map.put(pos(Column.A, Row.TWO), new Piece(Team.CHO, PieceType.SOLDIER));
+            map.put(pos(Column.A, Row.FOUR), new Piece(Team.CHO, PieceType.SOLDIER));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("a0 a6"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("포는 포를 넘어서 이동할 수 없다")
+        void cannonCannotJumpOverAnotherCannon() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.A, Row.ZERO), new Piece(Team.HAN, PieceType.CANNON));
+            map.put(pos(Column.A, Row.FOUR), new Piece(Team.CHO, PieceType.CANNON)); // cannon as jump target
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("a0 a7"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("포는 포를 잡을 수 없다")
+        void cannonCannotCaptureEnemyCannon() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.A, Row.ZERO), new Piece(Team.HAN, PieceType.CANNON));
+            map.put(pos(Column.A, Row.THREE), new Piece(Team.CHO, PieceType.SOLDIER));
+            map.put(pos(Column.A, Row.SIX), new Piece(Team.CHO, PieceType.CANNON));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("a0 a6"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("포는 아군 기물이 있는 위치로 이동할 수 없다")
+        void cannonCannotCaptureFriendlyPiece() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.A, Row.ZERO), new Piece(Team.HAN, PieceType.CANNON));
+            map.put(pos(Column.A, Row.THREE), new Piece(Team.CHO, PieceType.SOLDIER));
+            map.put(pos(Column.A, Row.SIX), new Piece(Team.HAN, PieceType.CHARIOT));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("a0 a6"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Nested
+    @DisplayName("마(HORSE) 이동 검증")
+    class HorseMovementValidation {
+
+        @Test
+        @DisplayName("마는 종점을 제외한 이동경로에 기물이 있으면 이동할 수 없다")
+        void horseCannotMoveWhenBlockingPositionIsOccupied() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FOUR), new Piece(Team.HAN, PieceType.HORSE));
+            map.put(pos(Column.E, Row.THREE), new Piece(Team.CHO, PieceType.SOLDIER));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("e4 d2"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+            assertThatThrownBy(() -> board.move(coord("e4 f2"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("마는 아군 기물이 있는 위치로 이동할 수 없다")
+        void horseCannotCaptureFriendlyPiece() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FOUR), new Piece(Team.HAN, PieceType.HORSE));
+            map.put(pos(Column.D, Row.TWO), new Piece(Team.HAN, PieceType.SOLDIER));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("e4 d2"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Nested
+    @DisplayName("상(ELEPHANT) 이동 검증")
+    class ElephantMovementValidation {
+
+        @Test
+        @DisplayName("상은 이동 경로가 모두 비어있으면 이동할 수 있다")
+        void elephantCanMoveWhenBothBlockingPositionsAreEmpty() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FOUR), new Piece(Team.HAN, PieceType.ELEPHANT));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            Board moved = board.move(coord("e4 c1"), turn);
+
+            assertThat(moved.isEmpty(pos(Column.E, Row.FOUR))).isTrue();
+            assertThat(moved.pieceAt(pos(Column.C, Row.ONE))).isPresent();
+        }
+
+        @Test
+        @DisplayName("상은 이동 경로 중 첫 번째 발 좌표에 기물이 있으면 이동할 수 없다")
+        void elephantCannotMoveWhenFirstBlockingPositionIsOccupied() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FOUR), new Piece(Team.HAN, PieceType.ELEPHANT));
+            map.put(pos(Column.E, Row.THREE), new Piece(Team.CHO, PieceType.SOLDIER));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("e4 c1"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("상은 이동 경로 중 두 번째 발 좌표에 기물이 있으면 이동할 수 없다")
+        void elephantCannotMoveWhenSecondBlockingPositionIsOccupied() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FOUR), new Piece(Team.HAN, PieceType.ELEPHANT));
+            map.put(pos(Column.D, Row.TWO), new Piece(Team.CHO, PieceType.SOLDIER)); // second blocking (e3->d2)
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("e4 c1"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+    }
+
+    @Nested
+    @DisplayName("궁(GENERAL) / 사(GUARD) 이동 검증")
+    class PalacePieceMovementValidation {
+
+        @Test
+        @DisplayName("궁은 인접한 빈 위치로 이동할 수 있다")
+        void generalCanMoveToAdjacentEmptyPosition() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FOUR), new Piece(Team.HAN, PieceType.GENERAL));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            Board moved = board.move(coord("e4 e5"), turn);
+
+            assertThat(moved.isEmpty(pos(Column.E, Row.FOUR))).isTrue();
+            assertThat(moved.pieceAt(pos(Column.E, Row.FIVE))).isPresent();
+        }
+
+        @Test
+        @DisplayName("궁은 인접한 아군 기물이 있는 위치로 이동할 수 없다")
+        void generalCannotCaptureFriendly() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FOUR), new Piece(Team.HAN, PieceType.GENERAL));
+            map.put(pos(Column.E, Row.FIVE), new Piece(Team.HAN, PieceType.GUARD));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("e4 e5"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("사는 궁과 동일하게 인접한 빈 위치로 이동할 수 있다")
+        void guardCanMoveToAdjacentEmptyPosition() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.D, Row.THREE), new Piece(Team.HAN, PieceType.GUARD));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            Board moved = board.move(coord("d3 d4"), turn);
+
+            assertThat(moved.isEmpty(pos(Column.D, Row.THREE))).isTrue();
+            assertThat(moved.pieceAt(pos(Column.D, Row.FOUR))).isPresent();
+        }
+    }
+
+    @Nested
+    @DisplayName("졸(SOLDIER) 이동 검증")
+    class SoldierMovementValidation {
+
+        @Test
+        @DisplayName("HAN 졸은 후진(row-1) 방향으로 이동할 수 없다")
+        void hanSoldierCannotMoveBackward() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FOUR), new Piece(Team.HAN, PieceType.SOLDIER));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.HAN);
+
+            assertThatThrownBy(() -> board.move(coord("e4 e3"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+
+        @Test
+        @DisplayName("CHO 졸은 후진(row+1) 방향으로 이동할 수 없다")
+        void choSoldierCannotMoveBackward() {
+            Map<Position, Piece> map = pieces();
+            map.put(pos(Column.E, Row.FIVE), new Piece(Team.CHO, PieceType.SOLDIER));
+            Board board = boardWith(map);
+            Turn turn = new Turn(Team.CHO);
+
+            assertThatThrownBy(() -> board.move(coord("e5 e6"), turn))
+                    .isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/src/test/java/domain/movement/PathTest.java b/src/test/java/domain/movement/PathTest.java
new file mode 100644
index 0000000000..6dad359204
--- /dev/null
+++ b/src/test/java/domain/movement/PathTest.java
@@ -0,0 +1,82 @@
+package domain.movement;
+
+import domain.board.Column;
+import domain.board.Position;
+import domain.board.Row;
+import org.junit.jupiter.api.DisplayName;
+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;
+
+@DisplayName("Path 클래스 테스트")
+class PathTest {
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    @Test
+    @DisplayName("contains: Path에 포함된 Position은 true를 반환한다")
+    void containsReturnsTrueForPositionInPath() {
+        Position middle = pos(Column.A, Row.TWO);
+        Path path = new Path(List.of(pos(Column.A, Row.ONE), middle, pos(Column.A, Row.THREE)));
+
+        assertThat(path.contains(middle)).isTrue();
+        assertThat(path.contains(pos(Column.A, Row.ONE))).isTrue();
+        assertThat(path.contains(pos(Column.A, Row.THREE))).isTrue();
+    }
+
+    @Test
+    @DisplayName("contains: Path에 없는 Position은 false를 반환한다")
+    void containsReturnsFalseForPositionNotInPath() {
+        Path path = new Path(List.of(pos(Column.A, Row.ONE), pos(Column.A, Row.TWO)));
+
+        assertThat(path.contains(pos(Column.B, Row.ONE))).isFalse();
+        assertThat(path.contains(pos(Column.A, Row.FIVE))).isFalse();
+    }
+
+    @Test
+    @DisplayName("endsAt: 마지막 Position에 true를 반환한다")
+    void endsAtReturnsTrueForLastPosition() {
+        Position last = pos(Column.C, Row.FIVE);
+        Path path = new Path(List.of(pos(Column.A, Row.FIVE), pos(Column.B, Row.FIVE), last));
+
+        assertThat(path.endsAt(last)).isTrue();
+    }
+
+    @Test
+    @DisplayName("endsAt: 마지막이 아닌 Position에 false를 반환한다")
+    void endsAtReturnsFalseForNonLastPosition() {
+        Path path = new Path(List.of(pos(Column.A, Row.FIVE), pos(Column.B, Row.FIVE), pos(Column.C, Row.FIVE)));
+
+        assertThat(path.endsAt(pos(Column.A, Row.FIVE))).isFalse();
+        assertThat(path.endsAt(pos(Column.B, Row.FIVE))).isFalse();
+        assertThat(path.endsAt(pos(Column.D, Row.FIVE))).isFalse();
+    }
+
+    @Test
+    @DisplayName("intermediates: 단일 이동 경로의 중간 좌표는 비어있다")
+    void intermediatesForSinglePositionPathIsEmpty() {
+        Path path = new Path(List.of(pos(Column.A, Row.ZERO)));
+
+        assertThat(path.intermediates()).isEmpty();
+    }
+
+    @Test
+    @DisplayName("intermediates: 여러 이동 경로에서 마지막을 제외한 모든 좌표를 반환한다")
+    void intermediatesReturnsAllButLastPosition() {
+        List<Position> positions = List.of(
+                pos(Column.A, Row.ONE),
+                pos(Column.A, Row.TWO),
+                pos(Column.A, Row.THREE)
+        );
+        Path path = new Path(positions);
+
+        assertThat(path.intermediates())
+                .containsExactly(pos(Column.A, Row.ONE), pos(Column.A, Row.TWO));
+    }
+
+}
diff --git a/src/test/java/domain/movement/SoldierMovementTest.java b/src/test/java/domain/movement/SoldierMovementTest.java
new file mode 100644
index 0000000000..d43896922e
--- /dev/null
+++ b/src/test/java/domain/movement/SoldierMovementTest.java
@@ -0,0 +1,61 @@
+package domain.movement;
+
+import domain.board.Column;
+import domain.board.Position;
+import domain.board.Row;
+import domain.piece.Team;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("SoldierMovement 클래스 테스트")
+class SoldierMovementTest {
+
+    private Position pos(Column column, Row row) {
+        return new Position(column, row);
+    }
+
+    private boolean canReach(Paths paths, Position target) {
+        return paths.asList().stream().anyMatch(p -> p.endsAt(target));
+    }
+
+    @Test
+    @DisplayName("HAN 졸은 전진(row+1), 좌, 우 방향으로 이동 가능하다")
+    void hanSoldierMovesForwardAndSideways() {
+        SoldierMovement movement = new SoldierMovement(Team.HAN);
+        Position pos = pos(Column.E, Row.FOUR);
+
+        Paths paths = movement.candidatePaths(pos);
+
+        assertThat(paths.asList()).hasSize(3);
+        assertThat(canReach(paths, pos(Column.E, Row.FIVE))).isTrue();
+        assertThat(canReach(paths, pos(Column.D, Row.FOUR))).isTrue();
+        assertThat(canReach(paths, pos(Column.F, Row.FOUR))).isTrue();
+    }
+
+    @Test
+    @DisplayName("CHO 졸은 전진(row-1), 좌, 우 방향으로 이동 가능하다")
+    void choSoldierMovesForwardAndSideways() {
+        SoldierMovement movement = new SoldierMovement(Team.CHO);
+        Position pos = pos(Column.E, Row.FIVE);
+
+        Paths paths = movement.candidatePaths(pos);
+
+        assertThat(paths.asList()).hasSize(3);
+        assertThat(canReach(paths, pos(Column.E, Row.FOUR))).isTrue();
+        assertThat(canReach(paths, pos(Column.D, Row.FIVE))).isTrue();
+        assertThat(canReach(paths, pos(Column.F, Row.FIVE))).isTrue();
+    }
+
+    @Test
+    @DisplayName("졸의 각 이동 경로는 1개의 좌표를 갖는다")
+    void eachPathHasOnePosition() {
+        SoldierMovement movement = new SoldierMovement(Team.HAN);
+        Paths paths = movement.candidatePaths(pos(Column.E, Row.FOUR));
+
+        paths.asList().forEach(path ->
+                assertThat(path.intermediates()).isEmpty()
+        );
+    }
+}
diff --git a/src/test/java/domain/piece/PieceTest.java b/src/test/java/domain/piece/PieceTest.java
new file mode 100644
index 0000000000..e0e6dc6418
--- /dev/null
+++ b/src/test/java/domain/piece/PieceTest.java
@@ -0,0 +1,86 @@
+package domain.piece;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("Piece 클래스 테스트")
+class PieceTest {
+
+    @Test
+    @DisplayName("getPieceType : 해당 기물 타입을 반환한다")
+    void getPieceTypeReturnsConstructedType() {
+        assertThat(new Piece(Team.HAN, PieceType.CANNON).getPieceType()).isEqualTo(PieceType.CANNON);
+        assertThat(new Piece(Team.CHO, PieceType.HORSE).getPieceType()).isEqualTo(PieceType.HORSE);
+    }
+
+    @Test
+    @DisplayName("isChariot : 차 기물에만 true를 반환한다")
+    void isChariotReturnsTrueOnlyForChariot() {
+        assertThat(new Piece(Team.HAN, PieceType.CHARIOT).isChariot()).isTrue();
+        assertThat(new Piece(Team.HAN, PieceType.CANNON).isChariot()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.GENERAL).isChariot()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.HORSE).isChariot()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.ELEPHANT).isChariot()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.GUARD).isChariot()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.SOLDIER).isChariot()).isFalse();
+    }
+
+    @Test
+    @DisplayName("isCannon : 포 기물에만 true를 반환한다")
+    void isCannonReturnsTrueOnlyForCannon() {
+        assertThat(new Piece(Team.HAN, PieceType.CANNON).isCannon()).isTrue();
+        assertThat(new Piece(Team.HAN, PieceType.CHARIOT).isCannon()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.GENERAL).isCannon()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.SOLDIER).isCannon()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.HORSE).isCannon()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.ELEPHANT).isCannon()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.GUARD).isCannon()).isFalse();
+    }
+
+    @Test
+    @DisplayName("isHorseOrElephant : 마와 상 기물에만 true를 반환한다")
+    void isHorseOrElephantReturnsTrueForHorseAndElephant() {
+        assertThat(new Piece(Team.HAN, PieceType.HORSE).isHorseOrElephant()).isTrue();
+        assertThat(new Piece(Team.HAN, PieceType.ELEPHANT).isHorseOrElephant()).isTrue();
+        assertThat(new Piece(Team.HAN, PieceType.CHARIOT).isHorseOrElephant()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.CANNON).isHorseOrElephant()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.GENERAL).isHorseOrElephant()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.GUARD).isHorseOrElephant()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.SOLDIER).isHorseOrElephant()).isFalse();
+    }
+
+    @Test
+    @DisplayName("isSoldier : 졸 기물에만 true를 반환한다")
+    void isSoldierReturnsTrueOnlyForSoldier() {
+        assertThat(new Piece(Team.HAN, PieceType.SOLDIER).isSoldier()).isTrue();
+        assertThat(new Piece(Team.HAN, PieceType.HORSE).isSoldier()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.ELEPHANT).isSoldier()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.CHARIOT).isSoldier()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.CANNON).isSoldier()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.GENERAL).isSoldier()).isFalse();
+        assertThat(new Piece(Team.HAN, PieceType.GUARD).isSoldier()).isFalse();
+    }
+
+    @Test
+    @DisplayName("isOwnedBy : 해당 팀 소유 기물에만 true를 반환한다")
+    void isOwnedByReturnsTrueForCorrectTeam() {
+        Piece hanPiece = new Piece(Team.HAN, PieceType.GENERAL);
+
+        assertThat(hanPiece.isOwnedBy(Team.HAN)).isTrue();
+        assertThat(hanPiece.isOwnedBy(Team.CHO)).isFalse();
+    }
+
+    @Test
+    @DisplayName("isSameTeamAs : 같은 팀 기물끼리만 true를 반환한다")
+    void isSameTeamAsReturnsTrueForSameTeam() {
+        Piece hanGeneral = new Piece(Team.HAN, PieceType.GENERAL);
+        Piece hanSoldier = new Piece(Team.HAN, PieceType.SOLDIER);
+        Piece choGeneral = new Piece(Team.CHO, PieceType.GENERAL);
+
+        assertThat(hanGeneral.isSameTeamAs(hanSoldier)).isTrue();
+        assertThat(hanGeneral.isSameTeamAs(choGeneral)).isFalse();
+        assertThat(choGeneral.isSameTeamAs(hanGeneral)).isFalse();
+    }
+}
diff --git a/src/test/java/domain/setup/ArrangementTest.java b/src/test/java/domain/setup/ArrangementTest.java
new file mode 100644
index 0000000000..eb45ae22da
--- /dev/null
+++ b/src/test/java/domain/setup/ArrangementTest.java
@@ -0,0 +1,34 @@
+package domain.setup;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("Arrangement 열거형 테스트")
+class ArrangementTest {
+
+    @Test
+    @DisplayName("toArrangement: '1'은 MASANGMASANG을 반환한다")
+    void toArrangementOneReturnsMaSangMaSang() {
+        assertThat(Arrangement.toArrangement("1")).isEqualTo(Arrangement.MASANGMASANG);
+    }
+
+    @Test
+    @DisplayName("toArrangement: '2'은 MASANGSANGMA 반환한다")
+    void toArrangementOneReturnsMaSangSangMa() {
+        assertThat(Arrangement.toArrangement("2")).isEqualTo(Arrangement.MASANGSANGMA);
+    }
+
+    @Test
+    @DisplayName("toArrangement: '4'는 SANGMAMASANG를 반환한다")
+    void toArrangementFourReturnsSangMaMaSang() {
+        assertThat(Arrangement.toArrangement("3")).isEqualTo(Arrangement.SANGMAMASANG);
+    }
+
+    @Test
+    @DisplayName("toArrangement: '4'는 SANGMASANGMA를 반환한다")
+    void toArrangementFourReturnsSangMaSangMa() {
+        assertThat(Arrangement.toArrangement("4")).isEqualTo(Arrangement.SANGMASANGMA);
+    }
+}
diff --git a/src/test/java/domain/setup/ArrangementsTest.java b/src/test/java/domain/setup/ArrangementsTest.java
new file mode 100644
index 0000000000..0fbf56d051
--- /dev/null
+++ b/src/test/java/domain/setup/ArrangementsTest.java
@@ -0,0 +1,21 @@
+package domain.setup;
+
+import domain.piece.Team;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("Arrangements 클래스 테스트")
+class ArrangementsTest {
+
+    @Test
+    @DisplayName("arrangeFor: 배치된 팀은 올바른 Arrangement를 반환한다")
+    void arrangeForAssignedTeamReturnsCorrectArrangement() {
+        Arrangements arrangements = new Arrangements()
+                .assignArrangement(Team.CHO, Arrangement.SANGMAMASANG);
+
+        assertThat(arrangements.arrangeFor(Team.CHO)).isEqualTo(Arrangement.SANGMAMASANG);
+    }
+}
diff --git a/src/test/java/domain/setup/CommandTest.java b/src/test/java/domain/setup/CommandTest.java
new file mode 100644
index 0000000000..97528135e9
--- /dev/null
+++ b/src/test/java/domain/setup/CommandTest.java
@@ -0,0 +1,48 @@
+package domain.setup;
+
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("Command 클래스 테스트")
+class CommandTest {
+
+    @Test
+    @DisplayName("toArrangement: 유효한 값('1'-'4')으로 상차림을 입력받는다.")
+    void toArrangementReturnsCorrectArrangement() {
+        assertThat(new Command("1").toArrangement()).isEqualTo(Arrangement.MASANGMASANG);
+        assertThat(new Command("2").toArrangement()).isEqualTo(Arrangement.MASANGSANGMA);
+        assertThat(new Command("3").toArrangement()).isEqualTo(Arrangement.SANGMAMASANG);
+        assertThat(new Command("4").toArrangement()).isEqualTo(Arrangement.SANGMASANGMA);
+    }
+
+    @ParameterizedTest(name = "toArrangement({0})은 유효한 값('1'-'4') 이외의 입력에 예외를 던진다")
+    @ValueSource(strings = {"0", "5", "abc", "", " "})
+    @DisplayName("toArrangement: 유효하지 않은 입력은 예외를 던진다")
+    void toArrangementThrowsForInvalidInput(String input) {
+        assertThatThrownBy(() -> new Command(input).toArrangement())
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    @DisplayName("toCoordinate: 유효한 좌표 형식을 Coordinate로 변환한다")
+    void toCoordinateReturnsCoordinate() {
+        Coordinate coordinate = new Command("a0 b1").toCoordinate();
+
+        assertThat(coordinate).isNotNull();
+        assertThat(coordinate.from()).isNotNull();
+        assertThat(coordinate.to()).isNotNull();
+    }
+
+    @ParameterizedTest(name = "toCoordinate({0})은 유효한 값(ex. 'a0 b2') 이외의 입력에 예외를 던진다")
+    @ValueSource(strings = {"a0", "a0b1", "a0 b1 c2", "", " ", "z0 a1"})
+    @DisplayName("toCoordinate: 유효하지 않은 좌표 형식은 예외를 던진다")
+    void toCoordinateThrowsForInvalidInput(String input) {
+        assertThatThrownBy(() -> new Command(input).toCoordinate())
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}
diff --git a/src/test/java/domain/setup/CoordinateTest.java b/src/test/java/domain/setup/CoordinateTest.java
new file mode 100644
index 0000000000..47cc5f6170
--- /dev/null
+++ b/src/test/java/domain/setup/CoordinateTest.java
@@ -0,0 +1,52 @@
+package domain.setup;
+
+import domain.board.Column;
+import domain.board.Position;
+import domain.board.Row;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("Coordinate 클래스 테스트")
+class CoordinateTest {
+
+    @Test
+    @DisplayName("toCoordinate: 좌표 입력을 올바르게 파싱한다")
+    void toCoordinateParseMixedCaseInput() {
+        Coordinate coord = Coordinate.toCoordinate("E5 f3");
+
+        assertThat(coord.from()).isEqualTo(new Position(Column.E, Row.FIVE));
+        assertThat(coord.to()).isEqualTo(new Position(Column.F, Row.THREE));
+    }
+
+    @Test
+    @DisplayName("올바른 좌표 입력에 대해 Position을 반환한다")
+    void fromAndToReturnCorrectPositions() {
+        Coordinate coord = Coordinate.toCoordinate("c3 g7");
+
+        assertThat(coord.from()).isEqualTo(new Position(Column.C, Row.THREE));
+        assertThat(coord.to()).isEqualTo(new Position(Column.G, Row.SEVEN));
+    }
+
+    @ParameterizedTest(name = "유효하지 않은 입력 '{0}'은 예외를 던진다")
+    @ValueSource(strings = {
+            "a0",
+            "a0b1",
+            "a0 b1 c2",
+            "",
+            " ",
+            "j0 a1",
+            "a10 b1",
+            "a  0 b1",
+    })
+    @DisplayName("toCoordinate: 유효하지 않은 입력은 예외를 던진다")
+    void toCoordinateThrowsForInvalidInput(String input) {
+        assertThatThrownBy(() -> Coordinate.toCoordinate(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("[ERROR]");
+    }
+}
diff --git a/src/test/java/domain/state/PlayingStateTest.java b/src/test/java/domain/state/PlayingStateTest.java
new file mode 100644
index 0000000000..1ab8d65ab6
--- /dev/null
+++ b/src/test/java/domain/state/PlayingStateTest.java
@@ -0,0 +1,88 @@
+package domain.state;
+
+import domain.board.Column;
+import domain.board.Position;
+import domain.board.Row;
+import domain.game.JanggiGame;
+import domain.piece.Team;
+import domain.setup.Command;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("PlayingState 클래스 테스트")
+class PlayingStateTest {
+
+    private JanggiGame game;
+
+    @BeforeEach
+    void setUp() {
+        game = new JanggiGame();
+        game.processCommand(new Command("1"));
+        game.processCommand(new Command("1"));
+    }
+
+    @Test
+    @DisplayName("설정 완료 후 CHO 팀 턴으로 시작한다")
+    void gameStartsWithChoTurn() {
+        assertThat(game.getTurn().display()).isEqualTo(Team.CHO.display());
+    }
+
+    @Test
+    @DisplayName("유효한 이동 명령을 처리하면 기물이 이동한다")
+    void handleValidMoveCommandMovesPiece() {
+        game.processCommand(new Command("e6 e5"));
+
+        assertThat(game.getBoard().isEmpty(new Position(Column.E, Row.SIX))).isTrue();
+        assertThat(game.getBoard().pieceAt(new Position(Column.E, Row.FIVE))).isPresent();
+    }
+
+    @Test
+    @DisplayName("이동 후 턴이 상대 팀으로 바뀐다")
+    void turnChangesToOpponentAfterMove() {
+        game.processCommand(new Command("e6 e5")); // CHO moves
+
+        assertThat(game.getTurn().display()).isEqualTo(Team.HAN.display());
+    }
+
+    @Test
+    @DisplayName("handle은 PlayingState를 계속 반환한다")
+    void handleReturnsPlayingState() {
+        PlayingState state = new PlayingState();
+
+        GameState nextState = state.handle(game, new Command("e6 e5"));
+
+        assertThat(nextState).isInstanceOf(PlayingState.class);
+    }
+
+    @Test
+    @DisplayName("유효하지 않은 좌표 형식은 예외를 던진다")
+    void invalidCoordinateFormatThrowsException() {
+        assertThatThrownBy(() -> game.processCommand(new Command("invalid")))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    @DisplayName("빈 위치에서 이동 시 예외를 던진다")
+    void moveFromEmptyPositionThrowsException() {
+        assertThatThrownBy(() -> game.processCommand(new Command("a4 a5")))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    @DisplayName("상대 팀의 기물을 이동 시 예외를 던진다")
+    void moveOpponentPieceThrowsException() {
+        assertThatThrownBy(() -> game.processCommand(new Command("a3 a4")))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    @DisplayName("유효하지 않은 이동 경로는 예외를 던진다")
+    void invalidMovePathThrowsException() {
+        assertThatThrownBy(() -> game.processCommand(new Command("e6 e7")))
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+}
diff --git a/src/test/java/domain/state/ReadyStateTest.java b/src/test/java/domain/state/ReadyStateTest.java
new file mode 100644
index 0000000000..060e73bd2a
--- /dev/null
+++ b/src/test/java/domain/state/ReadyStateTest.java
@@ -0,0 +1,51 @@
+package domain.state;
+
+import domain.game.JanggiGame;
+import domain.piece.Team;
+import domain.setup.Arrangement;
+import domain.setup.Arrangements;
+import domain.setup.Command;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("ReadyState 클래스 테스트")
+class ReadyStateTest {
+
+    @Test
+    @DisplayName("HAN 배치가 없을 때 명령 처리 시 HAN 배치가 등록되고 ReadyState를 반환한다")
+    void handleFirstCommandRegistersHanArrangementAndReturnsReadyState() {
+        Arrangements arrangements = new Arrangements();
+        ReadyState state = new ReadyState(arrangements);
+        JanggiGame game = new JanggiGame();
+
+        GameState nextState = state.handle(game, new Command("1"));
+
+        assertThat(nextState).isInstanceOf(ReadyState.class);
+    }
+
+    @Test
+    @DisplayName("HAN 배치 입력 후 턴이 CHO로 변경된다")
+    void afterHanArrangementTurnChangesToCho() {
+        Arrangements arrangements = new Arrangements();
+        ReadyState state = new ReadyState(arrangements);
+        JanggiGame game = new JanggiGame();
+
+        state.handle(game, new Command("1"));
+
+        assertThat(game.getTurn().display()).isEqualTo(Team.CHO.display());
+    }
+
+    @Test
+    @DisplayName("JanggiGame을 통해 두 번 명령하면 PlayingState로 전환된다")
+    void gameTransitionsToPlayingStateAfterTwoArrangements() {
+        JanggiGame game = new JanggiGame();
+
+        game.processCommand(new Command("3"));
+        game.processCommand(new Command("4"));
+
+        assertThat(game.getBoard()).isNotNull();
+    }
+}