diff --git a/README.md b/README.md
index 3150c08..c4a91c0 100644
--- a/README.md
+++ b/README.md
@@ -1,24 +1,78 @@
 # 미션 - 워들
 
-## 🔍 진행 방식
+## 🔍 진행 요구 사항
+- 미션은 아래의 세 가지 요구 사항으로 구성되어 있고, 각 요구 사항들을 만족하기 위해 노력한다.
 
-- 미션은 **과제 진행 요구 사항**, **기능 요구 사항**, **프로그래밍 요구 사항** 세 가지로 구성되어 있다.
-- 세 개의 요구 사항을 만족하기 위해 노력한다. 특히 기능을 구현하기 전에 기능 목록을 만들고, 기능 단위로 커밋 하는 방식으로 진행한다.
+### [**1. 진행 요구 사항**](#-기능-요구-사항)
+
+- 미션은 `페어프로그래밍`으로 진행한다.
+    > 유스방 5기 - Team 돌쓰
+    >   - boradol
+    >   - yooth
+
+### [**2. 프로그래밍 요구 사항**](#-프로그래밍-요구-사항)
+- 구현 전 환경구성이 프로그래밍 요구 사항을 확인하고 프로그래밍 요구 사항을 목록화한다.
+- 구현 중 필요한 프로그래밍 요구사항들을 만족하기 위해 노력한다.
+- 제출 전 프로그래밍 요구 사항을 지켰는지 확인한다.
+     
+### [**3. 기능 요구 사항**](#-기능-요구-사항)
+- 기능을 구현하기 전에 기능 요구 사항을 참고하여 **기능 목록**을 만든다.
+  - 페어프로그래밍을 위해 **용어를 정리**한다.
+  - [**용어 정리**](#-용어-정리)와 [**기능 목록**](#-기능-목록)은 계속 수정될 수 있다.
+- **기능 단위로 커밋** 하는 방식으로 진행한다.
 - **기능 요구 사항에 기재되지 않은 내용은 스스로 판단하여 구현한다.**
+---
+
+## 🎯 프로그래밍 요구 사항
+
+### 환경
+- Kotlin 1.9.23에서 실행.
+  - **Java 코드가 아닌 Kotlin 코드로만 구현해야 한다.**
+
+### 구현 전 확인 사항
+- [x] 프로그램 실행의 시작점은 `Application`의 `main()`이다.
+- [x] `build.gradle.kts` 파일은 변경할 수 없으며, **제공된 라이브러리 이외의 외부 라이브러리는 사용하지 않는다.**
+  - `Unknown Kotlin JVM target: 21` 문제로 `kotlin 1.9.23`으로 올림
+  - [문제해결](https://github.com/gradle/gradle/issues/25574#issuecomment-1761314551)
+- [x] 프로그램 종료 시 `System.exit()` 또는 `exitProcess()`를 호출하지 않는다.
+- [x] 프로그래밍 요구 사항에서 달리 명시하지 않는 한 파일, 패키지 등의 이름을 바꾸거나 이동하지 않는다.
+
+### 구현 중 필요 사항
+- [x] 코틀린 코드 컨벤션[(Kotlin Coding conventions)](https://kotlinlang.org/docs/coding-conventions.html)을 지키면서 프로그래밍한다.
+  - Commit 전에 `ktlint`를 습관적으로 확인한다.
+    - ```./gradlew ktlintCheck```
+    - ```./gradlew addKtlintCheckGitPreCommitHook```
+- [x] indent(인덴트, 들여쓰기) depth를 3이 넘지 않도록 구현한다. 2까지만 허용한다.
+- [x] 함수(또는 메서드)가 한 가지 일만 하도록 최대한 작게 만들어라.
+- [x] 함수(또는 메서드)의 길이가 15라인을 넘어가지 않도록 구현한다.
+- [x] 도메인 로직에 단위 테스트를 구현해야 한다.
+  - `JUnit 5`와 `AssertJ`를 이용하여 정리한 기능 목록이 정상적으로 작동하는지 테스트 코드로 확인한다.
+    - [JUnit 5 User Guide](https://junit.org/junit5/docs/current/user-guide)
+    - [AssertJ User Guide](https://assertj.github.io/doc)
+    - [AssertJ Exception Assertions](https://www.baeldung.com/assertj-exception-assertion)
+    - [Guide to JUnit 5 Parameterized Tests](https://www.baeldung.com/parameterized-tests-junit-5)
+  - 단, UI(System.out, System.in, Scanner) 로직은 제외한다.
+- [x] 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 분리해 구현한다.
+  - 힌트: MVC 패턴 기반으로 구현한 후, View와 Controller를 제외한 Model에 대한 단위 테스트 추가에 집중한다.
+
+### 제출 전 확인 사항
+- [x] 위의 프로그래밍 요구 사항을 준수했는지 확인한다.
+  - 체크박스를 모두 [x]로 만드는 것을 목표로 한다.
 
 ---
 
 ## 🚀 기능 요구 사항
 
-선풍적인 인기를 끌었던 영어 단어 맞추기 게임이다.
+### 워들 게임 규칙
 
-- 6x5 격자를 통해서 5글자 단어를 6번 만에 추측한다.
-- 플레이어가 답안을 제출하면 프로그램이 정답과 제출된 단어의 각 알파벳 종류와 위치를 비교해 판별한다.
-- 판별 결과는 흰색의 타일이 세 가지 색(초록색/노란색/회색) 중 하나로 바뀌면서 표현된다.
-    - 맞는 글자는 초록색, 위치가 틀리면 노란색, 없으면 회색
-    - 두 개의 동일한 문자를 입력하고 그중 하나가 회색으로 표시되면 해당 문자 중 하나만 최종 단어에 나타난다.
-- 정답과 답안은 `words.txt`에 존재하는 단어여야 한다.
-- 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
+>선풍적인 인기를 끌었던 영어 단어 맞추기 게임이다.
+>- 6x5 격자를 통해서 5글자 단어를 6번 만에 추측한다.
+>- 플레이어가 답안을 제출하면 프로그램이 정답과 제출된 단어의 각 알파벳 종류와 위치를 비교해 판별한다.
+>- 판별 결과는 흰색의 타일이 세 가지 색(초록색/노란색/회색) 중 하나로 바뀌면서 표현된다.
+>    - 맞는 글자는 초록색, 위치가 틀리면 노란색, 없으면 회색
+>    - 두 개의 동일한 문자를 입력하고 그중 하나가 회색으로 표시되면 해당 문자 중 하나만 최종 단어에 나타난다.
+>- 정답과 답안은 `words.txt`에 존재하는 단어여야 한다.
+>- 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
 
 ### 입출력 요구 사항
 
@@ -27,6 +81,7 @@
 ```
 WORDLE을 6번 만에 맞춰 보세요.
 시도의 결과는 타일의 색 변화로 나타납니다.
+
 정답을 입력해 주세요.
 hello
 
@@ -48,38 +103,158 @@ spell
 정답을 입력해 주세요.
 spill
 
-4/6
-
 ⬜⬜🟨🟩⬜
 🟨⬜⬜⬜🟩
 🟩🟩⬜🟩🟩
 🟩🟩🟩🟩🟩
+
+성공!! 정답입니다. 4/6
 ```
 
----
+### ✏️ 용어 정리
 
-## 🎯 프로그래밍 요구 사항
+| 국문          | 영문                | 설명                                                                                                           |
+|-------------|-------------------|--------------------------------------------------------------------------------------------------------------|
+| 워들 게임       | Wordle Game       | 알파벳 소문자로만 이루어진 5글자 영어 단어를 6번 만에 맞추는 게임이다.                                                                    |
+| 단어          | Word              | 워들 게임에서 플레이어가 입력해야 하는 최소 단위이다.                                                                               |
+| 사전          | Dictionary        | 유효한 단어들의 목록이다. 이 목록에서 정답 단어를 가져오고 답안 단어의 유효함을 확인한다.                                                          |
+| 기준 날짜       | Criterion Date    | 단어 사전에서 한 단어를 가져오는 계산에 필요한 기준 날짜이다.                                                                          |
+| 답안 단어       | Answer Word       | 플레이어가 정답이 되는 단어를 맞추기 위해 입력하는 단어이다.                                                                           |
+| 오늘의 단어      | Today Word        | 정답이 되는 단어이다. 기준 날짜와 오늘의 날짜를 계산하여 단어 사전에서 단어 하나를 가져온다. 이 단어는 매일 바뀐다.                                          |
+| 글자          | Letter            | 답안 단어와 오늘의 단어가 일치하는지 확인하는 최소 단위이다. 글자 여러 개가 모여 단어를 구성한다. 예) "hello"는 'h', 'e', 'l', 'o'의 글자로 이루어져 있다.        |
+| 워들 게임 로직    | Wordle Game Logic | 답안 단어와 오늘의 단어를 비교한 단어 결과를 받아 온다.                                                                             |
+| 단어 비교기      | Word Comparator   | 답안 단어와 오늘의 단어를 각 글자의 일치를 검증하는 기능을 한다.                                                                        |
+| 시도 가능 횟수    | Try Count         | 답안 단어를 입력 가능한 횟수이다. 유효한 단어를 입력할 때마다 1회씩 차감되며, 0회가 되면 게임은 무조건 종료된다.                                           |
+| 최대 시도 가능 횟수 | Max Try Count     | 유효한 답안을 입력할 수 있는 최대 횟수이다.                                                                                    |
+| 시도한 횟수      | Attempt Count     | 유효한 답안 단어를 입력한 횟수이다. ([최대 시도 가능 횟수] - [시도 가능 횟수])                                                            |
+| 단어 결과       | Word Result       | 유효한 답안 단어를 입력 후 해당 답안 단어에 대한 비교를 거친 후 각 글자 일치 상태 목록을 가지고 있다.                                                 |
+| 단어 결과 목록    | Word Results      | 글자 일치 상태 목록과 시도 가능 횟수를 가지고 있는 목록이다.                                                                          |
+| 글자 일치 상태    | Letter Match      | 답안 단어와 오늘의 단어를 이루는 각 글자들의 일치하는 상태를 나타내는 유형이다.                                                                |
+| 완전 일치 글자    | Correct Letter    | 글자 일치 상태 중, 같은 위치에 있는 답안 단어와 오늘의 단어의 글자가 같을 때의 상태이다.                                                         |
+| 부분 일치 글자    | Present Letter    | 글자 일치 상태 중, 다른 위치에 있는 글자가 오늘의 단어에 존재하는 상태이다. 이 때, 오늘의 단어에서 한번 비교한 부분 일치 글자는 다음 위치에 같은 부분 일치 글자가 나와도 비교하지 않는다. |
+| 불일치 글자      | Absent Letter     | 글자 일치 상태 중, 오늘의 단어에 해당 글자가 없는 상태이다.                                                                          |
+| 일치 표시 기호    | Match Marker      | 오늘의 단어 중 답안의 단어와 불일치 상태가 아닌 글자를 표시하는 기호이다.                                                                   |
+| 타일          | Tile              | 단어 비교의 각 글자별 결과를 타일의 색깔로 나타낸다. 글자 일치 상태와 대응 된다.                                                              |
+| 초록색 타일      | Green Tile        | 글자 완전 일치 상태의 결과를 나타낸 색상의 타일이다.                                                                               |
+| 노란색 타일      | Yellow Tile       | 글자 부분 일치 상태의 결과를 나타낸 색상의 타일이다.                                                                               |
+| 회색 타일       | Grey Tile         | 글자 불일치 상태의 결과를 나타낸 색상의 타일이다.                                                                                 |
+| 성공          | Success           | 워들 게임에서 답안의 단어가 오늘의 단어의 모든 글자가 완전 일치한 상태이다. 시도한 횟수를 알려주며 게임이 종료된다.                                           |
+| 실패          | Fail              | 워들 게임을 성공하지 못한 상태에서 시도 가능 횟수가 0회 이하가 되면 워들 게임에 실패한다. 오늘의 단어를 알려주며 게임이 종료된다.                                  |
+| 계속          | Continuous        | 워들 게임을 성공하지 못한 상태에서 시도 가능 횟수가 0회보다 크면 게임을 계속 시도해볼 수 있다.                                                      |
+| 다시 시도       | Retry             | 유효한 단어를 입력하지 못할 때, 시도 가능 횟수가 차감되지 않는다. 이 때, 유효하지 않은 이유를 안내하며 다시 답안을 입력하게 한다.                                 |
+|             |                   |                                                                                                              |
+
+
+### 💻 기능 목록
+
+#### 출력(Output View)
+- [x] 게임 시작 메시지를 출력한다.
+  - `WORDLE을 6번 만에 맞춰 보세요.\n시도의 결과는 타일의 색 변화로 나타납니다.`
+- [x] 타일 결과를 출력한다.
+  - [x] 플레이어가 입력한 답안 단어와 비교한 답안 결과에 따라 각 글자의 일치 상태에 맞게 타일을 출력한다.
+    - `🟩` 초록색: 오늘의 단어와 비교하여 답안 단어의 글자가 '완전 일치'인 경우
+    - `🟨` 노란색: 오늘의 단어와 비교하여 답안 단어의 글자가 '부분 일치'인 경우
+    - `⬜️` 회색: 오늘의 단어와 비교하여 답안 단어의 글자가 '불일치'인 경우
+  - [x] 지금까지 입력한 답안 단어에 따른 단어 결과 목록을 출력한다.
+- [x] 다시 시도 할 때, 다시 시도의 메시지와 그 이유를 함께 출력한다.
+- [x] 게임의 결과에 따라 메시지를 출력한다
+  - [x] 성공 메시지를 출력한다. `{시도한 횟수} / {최대 시도 가능 횟수}`도 함께 출력한다.
+  - [x] 실패 메시지를 출력한다. `{오늘의 단어}`를 함께 출력한다.
+
+#### 입력(Input View)
+- [x] 답안 단어를 입력받는다. 입력받기 전에 답안 입력을 위한 메시지를 먼저 출력한다.
+  - `정답을 입력해 주세요.`
+
+#### 워들 게임(Wordle Game)
+- [x] 단어 결과 목록을 가진다.
+- [x] 유효한 답안 단어를 최대 6번 입력받아 게임을 한다.
+  - [x] 게임에 아직 성공하지 못한 상태에서 시도 가능 횟수가 0보다 크면 게임을 계속 할 수 있다.
+  - [x] 단어를 입력받아 답안 단어를 만든다.
+    - 유효한 답안 단어를 입력 하였을 때,
+      - [x] 게임 검증 로직을 수행한다.
+      - [x] 타일 결과 목록을 출력한다.
+      - [x] 시행 가능 횟수를 1회 차감한다.
+    - 유효하지 않은 답안 단어를 입력 하였을 때, 
+      - [x] 답안 단어 입력을 다시 시도해야 한다. 다시 시도 하는 이유를 출력한다.
+- [x] 단어 결과 목록과 대응하는 타일 결과 목록을 출력한다.
+  - [x] 답안 단어 1번 입력하는 경우
+  - [x] 답안 단어를 6번 입력하고 게임에 실패하는 경우
+- [x] 게임이 종료 된다. 게임의 성공과 실패 여부를 판별한다.
+  - 게임에 성공 하였을 때
+    - [x] 해당 답안 단어의 단어 결과가 모두 '완전 일치 글자'일 때이다.
+      - 관련 메시지 출력
+  - 게임에 실패 하였을 때
+    - [x] 게임에 성공하지 않고, 시도횟수가 0회가 될 때이다.
+
+#### 글자(Letter)
+- [x] 글자는 하나의 문자를 가진다.
+- [x] 글자는 소문자 알파벳이나 일치 표시 기호('#')만 유효하다.
+- [x] 일치 표시 기호가 들어간 글자로 변경할 수 있다.
+
+#### 단어(Word)
+- [x] 단어는 여러 개의 글자로 이루어진다.
+- [x] 단어는 공백만 입력할 수 없다.
+- [x] 단어의 길이는 5자 이어야 한다.
+- [x] 단어는 사전에 있는 단어이어야 한다.
+
+#### 사전(Dictionary)
+- [x] 사전 단어 목록에서 단어 하나를 가져온다.
+  - `DictionaryFileLoader`를 이용하여 `words.txt`파일에서 사전의 단어 목록을 불러온다.
+- [x] 사전에 단어가 포함되는지 판별한다.
+  - 'hello'는 사전에 포함된 단어이다
+  - 'abced'는 사전에 포함되지 않은 단어이다.
+
+#### 오늘의 단어(Today Word)
+- [x] 오늘의 단어는 현재 날짜를 입력하여 사전에서 한 단어를 불러온다. 이때, 오늘의 단어는 매일 바뀐다.
+  - [x] 사전 단어 목록의 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
+
+#### 워들 게임 로직(Wordle Game Logic)
+- [x] 오늘의 단어와 답안 단어를 비교하여 단어 결과를 얻는다.
+  - 단어 결과 중 글자 일치 상태가 하나만 다른 경우
+    - [x] 하나의 글자 결과만 '부분 일치 글자'일 때 비교한다.
+    - [x] 하나의 글자 결과만 '완전 일치 글자'일 때 비교한다. - '완전 일치 글자'부터 비교한다
+  - 답안 단어에 같은 글자가 있는 경우
+    - [x] 두 번 같은 글자가 연속되는 답안 단어에서, 오늘의 단어와 한 글자만 '부분 일치 글자'일 때 비교한다.
+    - [x] 두 번 같은 글자가 연속되는 답안 단어에서, 오늘의 단어와 두 글자 '부분 일치 글자'일 때 비교한다.
+    - [x] 두 번 같은 글자가 연속되는 답안 단어에서, '부분 일치 글자'와 '완전 일치 글자'를 가질 때 비교한다.
+    - [x] 같은 글자가 연속 하지 않는 답안 단어에서, '부분 일치 글자'와 '완전 일치 글자'를 가질 때 비교한다.
+    - [x] 세 개의 같은 글자를 가지는 답안 단어에서 하나의 글자 결과만 '부분 일치 글자'일 때 비교한다.
+    - [x] 네 개의 글자 결과가 '완전 일치 글자'일 때 비교한다.
+  - 단어 결과 중 글자 일치 상태가 모두 같은 경우
+    - [x] 모든 글자 결과가 '불일치 상태'일 때 비교한다
+    - [x] 모든 글자 결과가 '부분 일치 글자'일 때 비교한다
+    - [x] 모든 글자 결과가 '완전 일치 글자'일 때 비교한다
+
+#### 단어 비교기(Word Comparator)
+- 단어 비교기는 글자 목록과 단어 결과를 상태로 가진다.
+- '완전 일치 글자'로 매칭 시키기
+  - [x] 완전 일치 글자를 비교한다. 완전 일치 글자의 상태는 ABSENT -> CORRECT 로 변경된다.
+    - [x] 위치와 글자가 같은 경우 체크한다.
+- '부분 일치 글자'로 매칭 시키기
+  - [x] '완전 일치 글자'매칭 후에 동작한다.
+  - [x] 부분 일치 글자를 비교한다. 부분 일치 글자의 상태는 ABSENT -> PRESENT 로 변경된다.
+    - [x] 해당 단어 비교기 글자는 '완전 일치 글자'가 아니여야 한다.
+    - [x] 각 글자는 다른 위치여야 한다.
+    - [x] 비교하려는 답안 단어의 글자는 비교기 글자 목록에 있는 글자여야 한다. 
+- [x] '완전 일치 글자'거나 '부분 일치 글자'이면 해당 단어 비교기 글자에 일치 표시 기호('#')로 변경된다.
+
+#### 시도 가능 횟수(Try Count)
+- [x] 시도 가능 회수는 횟수를 가진다. 최초 생성할 때에는 6회이다.
+- [x] 시도한 횟수를 구할 수 있다.
+- [x] 시도 가능 횟수가 남았는지 알 수 있다.
+- [x] 시도 가능 횟수를 1회씩 차감할 수 있다.
+- [x] 시도 가능 횟수는 0회보다 커야 한다.
+
+#### 단어 결과(Word Result)
+- [x] 5개의 글자 일치 상태 목록으로 이루어져 있다.
+  - 워들 게임 로직의 결과를 관리한다.
+- [x] 처음에 생성할 때, 글자 일치 상태는 불일치 상태이다.
+- [x] 해당 글자의 글자 일치 상태를 변경할 수 있다.
+- [x] 해당 글자가 '완전 일치 상태'인지 확인한다.
+- [x] 모든 글자 일치 상태가 '완전 일치 상태'이면, 해당 단어는 오늘의 단어와 같다.(게임 성공 여부가 된다)
 
-- Kotlin 1.9.0에서 실행 가능해야 한다.
-- **Java 코드가 아닌 Kotlin 코드로만 구현해야 한다.**
-- 프로그램 실행의 시작점은 `Application`의 `main()`이다.
-- `build.gradle.kts` 파일은 변경할 수 없으며, **제공된 라이브러리 이외의 외부 라이브러리는 사용하지 않는다.**
-- 프로그램 종료 시 `System.exit()` 또는 `exitProcess()`를 호출하지 않는다.
-- 프로그래밍 요구 사항에서 달리 명시하지 않는 한 파일, 패키지 등의 이름을 바꾸거나 이동하지 않는다.
-- 코틀린 코드 컨벤션을 지키면서 프로그래밍한다.
-    - 기본적으로 [Kotlin Coding conventions](https://kotlinlang.org/docs/coding-conventions.html)를 원칙으로 한다.
-- indent(인덴트, 들여쓰기) depth를 3이 넘지 않도록 구현한다. 2까지만 허용한다.
-    - 예를 들어 while문 안에 if문이 있으면 들여쓰기는 2이다.
-    - 힌트: indent(인덴트, 들여쓰기) depth를 줄이는 좋은 방법은 함수(또는 메서드)를 분리하면 된다.
-- 함수(또는 메서드)가 한 가지 일만 하도록 최대한 작게 만들어라.
-- JUnit 5와 AssertJ를 이용하여 정리한 기능 목록이 정상적으로 작동하는지 테스트 코드로 확인한다.
-    - 테스트 도구 사용법이 익숙하지 않다면 아래 문서를 참고하여 학습한 후 테스트를 구현한다.
-        - [JUnit 5 User Guide](https://junit.org/junit5/docs/current/user-guide)
-        - [AssertJ User Guide](https://assertj.github.io/doc)
-        - [AssertJ Exception Assertions](https://www.baeldung.com/assertj-exception-assertion)
-        - [Guide to JUnit 5 Parameterized Tests](https://www.baeldung.com/parameterized-tests-junit-5)
-- 함수(또는 메서드)의 길이가 15라인을 넘어가지 않도록 구현한다.
-    - 함수(또는 메서드)가 한 가지 일만 잘 하도록 구현한다.
-- 도메인 로직에 단위 테스트를 구현해야 한다. 단, UI(System.out, System.in, Scanner) 로직은 제외한다.
-    - 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 분리해 구현한다.
-    - 힌트: MVC 패턴 기반으로 구현한 후, View와 Controller를 제외한 Model에 대한 단위 테스트 추가에 집중한다.
+#### 단어 결과 목록(Word Results)
+- [x] 단어결과와 시도횟수를 가진다. 이때, 단어결과 목록은 빈 목록이고, 시도한 횟수는 0이다.
+- [x] 단어 결과를 추가하면, 시도횟수는 1회 증가한다.
+- [x] 단어 결과 목록에서 단어 결과가 성공인 상태가 추가되면 게임은 성공한다.
+- [x] 단어 결과 목록에서 아직 게임 성공하지 못하고 시도 가능 횟수가 1 이상이면 게임을 계속할 수 있다. 
diff --git a/build.gradle.kts b/build.gradle.kts
index 19a215a..ab9c11f 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,5 +1,5 @@
 plugins {
-    kotlin("jvm") version "1.9.0"
+    kotlin("jvm") version "1.9.23"
     id("org.jlleitschuh.gradle.ktlint") version "12.1.0"
 }
 
@@ -14,9 +14,12 @@ repositories {
     mavenCentral()
 }
 
+val junitJupiterVersion = "5.10.2"
+val assertJVersion = "3.25.3"
+
 dependencies {
-    testImplementation("org.junit.jupiter", "junit-jupiter", "5.10.2")
-    testImplementation("org.assertj", "assertj-core", "3.25.3")
+    testImplementation("org.junit.jupiter", "junit-jupiter", junitJupiterVersion)
+    testImplementation("org.assertj", "assertj-core", assertJVersion)
 }
 
 tasks {
diff --git a/src/main/kotlin/.gitkeep b/src/main/kotlin/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/kotlin/wordle/Application.kt b/src/main/kotlin/wordle/Application.kt
new file mode 100644
index 0000000..7cdfcc2
--- /dev/null
+++ b/src/main/kotlin/wordle/Application.kt
@@ -0,0 +1,7 @@
+package wordle
+
+import wordle.controller.WordleGameController
+
+fun main() {
+    WordleGameController().run()
+}
diff --git a/src/main/kotlin/wordle/application/WordleGame.kt b/src/main/kotlin/wordle/application/WordleGame.kt
new file mode 100644
index 0000000..51cf861
--- /dev/null
+++ b/src/main/kotlin/wordle/application/WordleGame.kt
@@ -0,0 +1,40 @@
+package wordle.application
+
+import wordle.domain.TodayWord
+import wordle.domain.Word
+import wordle.domain.WordResults
+import wordle.domain.WordleGameLogic
+import wordle.view.inputAnswerWord
+import wordle.view.printFail
+import wordle.view.printRetry
+import wordle.view.printSuccess
+import wordle.view.printWordResults
+import java.time.LocalDate
+
+class WordleGame(gameStartDate: LocalDate) {
+    private val todayWord = TodayWord(gameStartDate)
+    private val wordleGameLogic = WordleGameLogic(todayWord)
+    private val results = WordResults()
+
+    fun play() {
+        while (results.isContinuousGame()) {
+            try {
+                val answerWord = Word(inputAnswerWord())
+                val result = wordleGameLogic.compare(answerWord)
+                results.addResults(result)
+                printWordResults(results)
+            } catch (e: IllegalStateException) {
+                printRetry(e.message)
+            }
+        }
+        printGameResult()
+    }
+
+    private fun printGameResult() {
+        if (results.isSuccessfulGame()) {
+            printSuccess(results.attemptCount)
+            return
+        }
+        printFail(todayWord)
+    }
+}
diff --git a/src/main/kotlin/wordle/controller/WordleGameController.kt b/src/main/kotlin/wordle/controller/WordleGameController.kt
new file mode 100644
index 0000000..aa05af0
--- /dev/null
+++ b/src/main/kotlin/wordle/controller/WordleGameController.kt
@@ -0,0 +1,15 @@
+package wordle.controller
+
+import wordle.application.WordleGame
+import wordle.view.printStartingGameMessage
+import java.time.LocalDate
+
+class WordleGameController {
+    private val gameStartDate: LocalDate = LocalDate.now()
+    private val wordleGame: WordleGame = WordleGame(gameStartDate)
+
+    fun run() {
+        printStartingGameMessage()
+        wordleGame.play()
+    }
+}
diff --git a/src/main/kotlin/wordle/domain/AnswerWord.kt b/src/main/kotlin/wordle/domain/AnswerWord.kt
new file mode 100644
index 0000000..ee35e0f
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/AnswerWord.kt
@@ -0,0 +1,7 @@
+package wordle.domain
+
+typealias AnswerWord = Word
+
+fun AnswerWord(answerWord: String): AnswerWord {
+    return Word(answerWord)
+}
diff --git a/src/main/kotlin/wordle/domain/Dictionary.kt b/src/main/kotlin/wordle/domain/Dictionary.kt
new file mode 100644
index 0000000..a929d76
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/Dictionary.kt
@@ -0,0 +1,8 @@
+package wordle.domain
+
+import wordle.infra.contains
+import wordle.infra.dictionaryWord
+
+fun isDictionaryWord(word: String): Boolean = contains(word)
+
+fun dictionaryElementAt(index: Int): String = dictionaryWord(index)
diff --git a/src/main/kotlin/wordle/domain/Letter.kt b/src/main/kotlin/wordle/domain/Letter.kt
new file mode 100644
index 0000000..102e79f
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/Letter.kt
@@ -0,0 +1,23 @@
+package wordle.domain
+
+import wordle.exception.WordleExceptionCode.LETTER_INVALID_CHARACTER_TYPE
+
+data class Letter(private val value: Char) {
+    init {
+        check(isAlphabet() || isMatchMarker()) { LETTER_INVALID_CHARACTER_TYPE.message }
+    }
+
+    fun changeMatchMarker(): Letter = MATCH_MARKER_LETTER
+
+    fun value(): String = value.toString()
+
+    private fun isAlphabet(): Boolean = value in ALPHABET
+
+    private fun isMatchMarker(): Boolean = value == MATCH_MARKER
+
+    companion object {
+        private const val MATCH_MARKER = '#'
+        private val ALPHABET = ('a'..'z').toSet()
+        private val MATCH_MARKER_LETTER = Letter(MATCH_MARKER)
+    }
+}
diff --git a/src/main/kotlin/wordle/domain/LetterMatch.kt b/src/main/kotlin/wordle/domain/LetterMatch.kt
new file mode 100644
index 0000000..bca68c0
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/LetterMatch.kt
@@ -0,0 +1,7 @@
+package wordle.domain
+
+enum class LetterMatch {
+    CORRECT,
+    PRESENT,
+    ABSENT,
+}
diff --git a/src/main/kotlin/wordle/domain/TodayWord.kt b/src/main/kotlin/wordle/domain/TodayWord.kt
new file mode 100644
index 0000000..2bbb60c
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/TodayWord.kt
@@ -0,0 +1,19 @@
+package wordle.domain
+
+import wordle.infra.dictionaryWord
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+
+typealias TodayWord = Word
+
+private val CRITERION_DATE: LocalDate = LocalDate.of(2021, 6, 19)
+
+fun TodayWord(today: LocalDate): TodayWord {
+    return Word(extractDictionaryWord(today))
+}
+
+private fun extractDictionaryWord(date: LocalDate): String {
+    val calculatedIndex = ChronoUnit.DAYS.between(CRITERION_DATE, date).toInt()
+
+    return dictionaryWord(calculatedIndex)
+}
diff --git a/src/main/kotlin/wordle/domain/TryCount.kt b/src/main/kotlin/wordle/domain/TryCount.kt
new file mode 100644
index 0000000..cd001db
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/TryCount.kt
@@ -0,0 +1,16 @@
+package wordle.domain
+
+import wordle.exception.WordleExceptionCode.TRY_COUNT_HAS_NOT_REMAINDER
+
+data class TryCount(private var count: Int = MAX_TRY_COUNT) {
+    val attempts get() = MAX_TRY_COUNT - count
+
+    fun isRemainder(): Boolean = count in 1..MAX_TRY_COUNT
+
+    fun minus() {
+        check(isRemainder()) { TRY_COUNT_HAS_NOT_REMAINDER.message }
+        this.count -= 1
+    }
+}
+
+const val MAX_TRY_COUNT = 6
diff --git a/src/main/kotlin/wordle/domain/Word.kt b/src/main/kotlin/wordle/domain/Word.kt
new file mode 100644
index 0000000..62a56d2
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/Word.kt
@@ -0,0 +1,21 @@
+package wordle.domain
+
+import wordle.exception.WordleExceptionCode.WORD_INVALID_LENGTH
+import wordle.exception.WordleExceptionCode.WORD_IS_NOT_IN_DICTIONARY
+import wordle.exception.WordleExceptionCode.WORD_NOT_ALLOW_SPACE
+
+data class Word(private val word: List<Letter>) : List<Letter> by word {
+    fun letters(): String = word.joinToString("", transform = Letter::value)
+}
+
+const val WORD_LENGTH = 5
+
+fun Word(word: String): Word {
+    check(word.isNotBlank()) { WORD_NOT_ALLOW_SPACE.message }
+    check(isValidLength(word)) { WORD_INVALID_LENGTH.message }
+    check(isDictionaryWord(word)) { WORD_IS_NOT_IN_DICTIONARY.message }
+
+    return Word(word.toCharArray().map { Letter(it) })
+}
+
+private fun isValidLength(word: String) = word.length == WORD_LENGTH
diff --git a/src/main/kotlin/wordle/domain/WordComparator.kt b/src/main/kotlin/wordle/domain/WordComparator.kt
new file mode 100644
index 0000000..16e97d0
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/WordComparator.kt
@@ -0,0 +1,60 @@
+package wordle.domain
+
+class WordComparator(
+    private val markerLetters: MutableList<Letter>,
+    private val wordResult: WordResult = WordResult(),
+) {
+    fun matchCorrect(answerWord: Word): WordComparator =
+        apply {
+            markerLetters.forEachIndexed { index, _ -> changeCorrectMatch(index, answerWord[index]) }
+        }
+
+    fun matchPresent(answerWord: Word): WordComparator =
+        apply {
+            markerLetters.forEachIndexed { index, _ -> changePresentMatch(index, answerWord[index]) }
+        }
+
+    fun result(): WordResult = wordResult
+
+    private fun changeCorrectMatch(
+        index: Int,
+        answerLetter: Letter,
+    ) {
+        if (isCorrectLetter(index, answerLetter)) {
+            wordResult.changeMatchType(index, LetterMatch.CORRECT)
+            changeMarkerLetter(index)
+        }
+    }
+
+    private fun changePresentMatch(
+        index: Int,
+        answerLetter: Letter,
+    ) {
+        if (isPresentLatter(index, answerLetter)) {
+            wordResult.changeMatchType(index, LetterMatch.PRESENT)
+            changeMarkerLetterIndexOf(answerLetter)
+        }
+    }
+
+    private fun isCorrectLetter(
+        index: Int,
+        answerLetter: Letter,
+    ) = markerLetters[index] == answerLetter
+
+    private fun isPresentLatter(
+        index: Int,
+        answerLetter: Letter,
+    ) = !(wordResult.isCorrectLetterMatch(index) || isCorrectLetter(index, answerLetter)) && (answerLetter in markerLetters)
+
+    private fun changeMarkerLetter(index: Int) {
+        markerLetters[index] = markerLetters[index].changeMatchMarker()
+    }
+
+    private fun changeMarkerLetterIndexOf(letter: Letter) {
+        changeMarkerLetter(markerLetters.indexOf(letter))
+    }
+}
+
+fun WordComparator(todayWord: Word): WordComparator {
+    return WordComparator(todayWord.map(Letter::copy).toMutableList())
+}
diff --git a/src/main/kotlin/wordle/domain/WordResult.kt b/src/main/kotlin/wordle/domain/WordResult.kt
new file mode 100644
index 0000000..f77a7d1
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/WordResult.kt
@@ -0,0 +1,22 @@
+package wordle.domain
+
+import wordle.exception.WordleExceptionCode.WORD_RESULT_INVALID_LENGTH
+
+data class WordResult(private val result: MutableList<LetterMatch> = MutableList(WORD_LENGTH) { LetterMatch.ABSENT }) {
+    init {
+        check(result.size == WORD_LENGTH) { WORD_RESULT_INVALID_LENGTH.message }
+    }
+
+    fun changeMatchType(
+        index: Int,
+        matchType: LetterMatch,
+    ) {
+        result[index] = matchType
+    }
+
+    fun isCorrectLetterMatch(index: Int): Boolean = result[index] == LetterMatch.CORRECT
+
+    fun isSuccessfulWordResult() = result.all { matchType -> matchType == LetterMatch.CORRECT }
+
+    fun matches(): List<LetterMatch> = result.toList()
+}
diff --git a/src/main/kotlin/wordle/domain/WordResults.kt b/src/main/kotlin/wordle/domain/WordResults.kt
new file mode 100644
index 0000000..e98b7fb
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/WordResults.kt
@@ -0,0 +1,19 @@
+package wordle.domain
+
+class WordResults(
+    private val results: MutableList<WordResult> = mutableListOf(),
+    private val tryCount: TryCount = TryCount(),
+) {
+    val attemptCount: Int get() = tryCount.attempts
+
+    fun addResults(result: WordResult) {
+        tryCount.minus()
+        results.add(result)
+    }
+
+    fun isContinuousGame(): Boolean = !isSuccessfulGame() && tryCount.isRemainder()
+
+    fun isSuccessfulGame(): Boolean = (tryCount.attempts != 0) && results.last().isSuccessfulWordResult()
+
+    fun wordResults(): List<List<LetterMatch>> = results.map { it.matches() }
+}
diff --git a/src/main/kotlin/wordle/domain/WordleGameLogic.kt b/src/main/kotlin/wordle/domain/WordleGameLogic.kt
new file mode 100644
index 0000000..e2baf0b
--- /dev/null
+++ b/src/main/kotlin/wordle/domain/WordleGameLogic.kt
@@ -0,0 +1,11 @@
+package wordle.domain
+
+class WordleGameLogic(private val todayWord: Word) {
+    fun compare(answerWord: Word): WordResult =
+        todayWord.comparator()
+            .matchCorrect(answerWord)
+            .matchPresent(answerWord)
+            .result()
+
+    private fun Word.comparator(): WordComparator = WordComparator(this)
+}
diff --git a/src/main/kotlin/wordle/exception/WordleExceptionCode.kt b/src/main/kotlin/wordle/exception/WordleExceptionCode.kt
new file mode 100644
index 0000000..cf1f51c
--- /dev/null
+++ b/src/main/kotlin/wordle/exception/WordleExceptionCode.kt
@@ -0,0 +1,12 @@
+package wordle.exception
+
+import wordle.domain.WORD_LENGTH
+
+enum class WordleExceptionCode(val message: String) {
+    WORD_NOT_ALLOW_SPACE("단어는 공백만 입력할 수 없습니다."),
+    WORD_INVALID_LENGTH("단어의 길이는 ${WORD_LENGTH}자 입니다."),
+    WORD_IS_NOT_IN_DICTIONARY("Wordle Game에서 유효한 단어가 아닙니다."),
+    LETTER_INVALID_CHARACTER_TYPE("유효하지 않은 글자 형식입니다."),
+    TRY_COUNT_HAS_NOT_REMAINDER("시행 횟수는 0보다 작을 수 없습니다."),
+    WORD_RESULT_INVALID_LENGTH("단어 결과의 글자 일치 상태 목록들은 단어 길이인 ${WORD_LENGTH}와 일치해야 합니다."),
+}
diff --git a/src/main/kotlin/wordle/infra/DictionaryFileLoader.kt b/src/main/kotlin/wordle/infra/DictionaryFileLoader.kt
new file mode 100644
index 0000000..8d4bcba
--- /dev/null
+++ b/src/main/kotlin/wordle/infra/DictionaryFileLoader.kt
@@ -0,0 +1,25 @@
+package wordle.infra
+
+import java.nio.charset.StandardCharsets
+
+private const val NEW_LINE = "\n"
+private const val WORDS_FILE_PATH = "words.txt"
+private val classLoader: ClassLoader = Thread.currentThread().contextClassLoader
+private val dictionaryWords: List<String> by lazy { loadDictionaryWords() }
+private val dictionaryWordSet: Set<String> by lazy { dictionaryWords.toSet() }
+val dictionaryWordsSize = dictionaryWords.size
+
+fun contains(word: String): Boolean = dictionaryWordSet.contains(word)
+
+fun dictionaryWord(index: Int): String {
+    check(dictionaryWords.isNotEmpty()) { NoSuchElementException("Dictionary File is Empty") }
+
+    return dictionaryWords[index % dictionaryWordsSize]
+}
+
+private fun loadDictionaryWords(): List<String> =
+    classLoader.getResourceAsStream(WORDS_FILE_PATH)
+        ?.bufferedReader(StandardCharsets.UTF_8)
+        ?.use { it.readText().split(NEW_LINE) }
+        ?.filter { it.isNotBlank() }
+        ?: throw IllegalArgumentException("Dictionary File not found: $WORDS_FILE_PATH")
diff --git a/src/main/kotlin/wordle/view/InputView.kt b/src/main/kotlin/wordle/view/InputView.kt
new file mode 100644
index 0000000..bc2cd40
--- /dev/null
+++ b/src/main/kotlin/wordle/view/InputView.kt
@@ -0,0 +1,6 @@
+package wordle.view
+
+fun inputAnswerWord(): String {
+    println("🚀 정답을 입력하세요. : ")
+    return readln()
+}
diff --git a/src/main/kotlin/wordle/view/OutputView.kt b/src/main/kotlin/wordle/view/OutputView.kt
new file mode 100644
index 0000000..fcdf2a4
--- /dev/null
+++ b/src/main/kotlin/wordle/view/OutputView.kt
@@ -0,0 +1,31 @@
+package wordle.view
+
+import wordle.domain.LetterMatch
+import wordle.domain.MAX_TRY_COUNT
+import wordle.domain.Word
+import wordle.domain.WordResults
+
+private const val ENTER = "\n"
+private const val SPACE = ""
+
+fun printStartingGameMessage() {
+    println("🎮 WORDLE을 ${MAX_TRY_COUNT}번 만에 맞춰 보세요.$ENTER📌 시도의 결과는 타일의 색 변화로 나타납니다.🥳$ENTER")
+}
+
+fun printWordResults(results: WordResults) {
+    println(results.wordResults().joinToString(ENTER) { printTiles(it) } + ENTER)
+}
+
+fun printRetry(message: String?) {
+    println("🥲 다시 시도하세요! : ${message ?: SPACE}$ENTER")
+}
+
+fun printSuccess(attemptCount: Int) {
+    println("🎉 성공입니다. $attemptCount / $MAX_TRY_COUNT")
+}
+
+fun printFail(todayWord: Word) {
+    println("👻 실패하였습니다. 오늘의 단어는 [ ${todayWord.letters()} ] 입니다.")
+}
+
+private fun printTiles(it: List<LetterMatch>) = it.joinToString(SPACE) { Tile.of(it).color }
diff --git a/src/main/kotlin/wordle/view/Tile.kt b/src/main/kotlin/wordle/view/Tile.kt
new file mode 100644
index 0000000..3b25a34
--- /dev/null
+++ b/src/main/kotlin/wordle/view/Tile.kt
@@ -0,0 +1,14 @@
+package wordle.view
+
+import wordle.domain.LetterMatch
+
+enum class Tile(val matchType: LetterMatch, val color: String) {
+    GREEN(LetterMatch.CORRECT, "🟩"),
+    YELLOW(LetterMatch.PRESENT, "🟨"),
+    GREY(LetterMatch.ABSENT, "⬜"),
+    ;
+
+    companion object {
+        fun of(matchType: LetterMatch): Tile = entries.find { tile -> tile.matchType == matchType } ?: GREY
+    }
+}
diff --git a/src/test/kotlin/.gitkeep b/src/test/kotlin/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/test/kotlin/wordle/application/WordleGameTest.kt b/src/test/kotlin/wordle/application/WordleGameTest.kt
new file mode 100644
index 0000000..4435003
--- /dev/null
+++ b/src/test/kotlin/wordle/application/WordleGameTest.kt
@@ -0,0 +1,189 @@
+package wordle.application
+
+import org.assertj.core.api.AssertionsForClassTypes.assertThat
+import org.junit.jupiter.api.Test
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.PrintStream
+import java.time.LocalDate
+
+private val GAME_START_DATE = LocalDate.of(2021, 6, 20)
+
+class WordleGameTest {
+    @Test
+    fun `6번 이내 오늘의 단어를 맞추면 성공 안내 문구를 출력한다`() {
+        val inputAnswerWords = successConsoleInput
+        val (printStream, outputStream) = printStreamByteArrayOutputStreamPair(inputAnswerWords)
+
+        WordleGame(GAME_START_DATE).play()
+        printStream(printStream)
+
+        assertThat(outputStream.toString().trimIndent()).isEqualTo(successConsolePrint.trimIndent())
+    }
+
+    @Test
+    fun `6번 이내 오늘의 단어를 맞추지 못하면 실패 안내 문구와 오늘의 단어를 출력한다`() {
+        val inputAnswerWords = failConsoleInput
+        val (printStream, outputStream) = printStreamByteArrayOutputStreamPair(inputAnswerWords)
+
+        WordleGame(GAME_START_DATE).play()
+        printStream(printStream)
+
+        assertThat(outputStream.toString().trimIndent()).isEqualTo(failConsolePrint.trimIndent())
+    }
+
+    @Test
+    fun `답안 입력 시 공백을 입력하면 다시 입력을 받는다`() {
+        val inputAnswerWords = "$blank$br$wordSpill"
+        val (printStream, outputStream) = printStreamByteArrayOutputStreamPair(inputAnswerWords)
+
+        WordleGame(GAME_START_DATE).play()
+        printStream(printStream)
+
+        assertThat(outputStream.toString().trimIndent()).isEqualTo(blankConsolePrint.trimIndent())
+    }
+
+    @Test
+    fun `답안 입력 시 정해진 단어의 길이와 다른 단어를 입력하면 다시 입력을 받는다`() {
+        val inputAnswerWords = "$invalidLengthWord$br$wordSpill"
+        val (printStream, outputStream) = printStreamByteArrayOutputStreamPair(inputAnswerWords)
+
+        WordleGame(GAME_START_DATE).play()
+        printStream(printStream)
+
+        assertThat(outputStream.toString().trimIndent()).isEqualTo(invalidLengthConsolePrint.trimIndent())
+    }
+
+    @Test
+    fun `답안 입력 시 단어 사전에 없는 단어를 입력하면 다시 입력을 받는다`() {
+        val inputAnswerWords = "$invalidWord$br$wordSpill"
+        val (printStream, outputStream) = printStreamByteArrayOutputStreamPair(inputAnswerWords)
+
+        WordleGame(GAME_START_DATE).play()
+        printStream(printStream)
+
+        assertThat(outputStream.toString().trimIndent()).isEqualTo(invalidWordConsolePrint.trimIndent())
+    }
+
+    private fun printStreamByteArrayOutputStreamPair(inputAnswerWords: String): Pair<PrintStream, ByteArrayOutputStream> {
+        val printStream = System.out
+        val outputStream = ByteArrayOutputStream()
+        val inputStream = ByteArrayInputStream(inputAnswerWords.toByteArray())
+
+        System.setOut(PrintStream(outputStream))
+        System.setIn(inputStream)
+
+        return Pair(printStream, outputStream)
+    }
+
+    private fun printStream(printStream: PrintStream) {
+        System.setOut(printStream)
+        System.setIn(System.`in`)
+    }
+
+    private val answerWordHello = "hello"
+    private val answerWordLabel = "label"
+    private val answerWordSpell = "spell"
+    private val wordSpill = "spill"
+    private val br = "\n"
+    private val blank = ""
+    private val invalidLengthWord = "word"
+    private val invalidWord = "abcde"
+    private val successConsoleInput = "$answerWordHello$br$answerWordLabel$br$answerWordSpell$br$wordSpill"
+    private val failConsoleInput =
+        "$answerWordHello$br$answerWordLabel$br$answerWordSpell$br$answerWordHello$br$answerWordLabel$br$answerWordSpell"
+
+    private val successConsolePrint =
+        """
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        🟩🟩⬜🟩🟩
+        
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        🟩🟩⬜🟩🟩
+        🟩🟩🟩🟩🟩
+        
+        🎉 성공입니다. 4 / 6
+        """
+
+    private val failConsolePrint =
+        """
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        🟩🟩⬜🟩🟩
+        
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        🟩🟩⬜🟩🟩
+        ⬜⬜🟨🟩⬜
+        
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        🟩🟩⬜🟩🟩
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        
+        🚀 정답을 입력하세요. : 
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        🟩🟩⬜🟩🟩
+        ⬜⬜🟨🟩⬜
+        🟨⬜⬜⬜🟩
+        🟩🟩⬜🟩🟩
+        
+        👻 실패하였습니다. 오늘의 단어는 [ spill ] 입니다.
+        """
+
+    private val blankConsolePrint =
+        """
+        🚀 정답을 입력하세요. : 
+        🥲 다시 시도하세요! : 단어는 공백만 입력할 수 없습니다.
+        
+        🚀 정답을 입력하세요. : 
+        🟩🟩🟩🟩🟩
+        
+        🎉 성공입니다. 1 / 6
+        """
+
+    private val invalidLengthConsolePrint =
+        """
+        🚀 정답을 입력하세요. : 
+        🥲 다시 시도하세요! : 단어의 길이는 5자 입니다.
+        
+        🚀 정답을 입력하세요. : 
+        🟩🟩🟩🟩🟩
+        
+        🎉 성공입니다. 1 / 6
+        """
+
+    private val invalidWordConsolePrint =
+        """
+        🚀 정답을 입력하세요. : 
+        🥲 다시 시도하세요! : Wordle Game에서 유효한 단어가 아닙니다.
+        
+        🚀 정답을 입력하세요. : 
+        🟩🟩🟩🟩🟩
+        
+        🎉 성공입니다. 1 / 6
+        """
+}
diff --git a/src/test/kotlin/wordle/domain/AnswerWordTest.kt b/src/test/kotlin/wordle/domain/AnswerWordTest.kt
new file mode 100644
index 0000000..87498fb
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/AnswerWordTest.kt
@@ -0,0 +1,13 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class AnswerWordTest {
+    @Test
+    fun `(성공) 답안 단어는 문자열을 입력받아 단어를 생성한다`() {
+        val actual = AnswerWord("hello")
+
+        assertThat(actual).isEqualTo(Word("hello"))
+    }
+}
diff --git a/src/test/kotlin/wordle/domain/DictionaryKtTest.kt b/src/test/kotlin/wordle/domain/DictionaryKtTest.kt
new file mode 100644
index 0000000..bafc43e
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/DictionaryKtTest.kt
@@ -0,0 +1,34 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Assertions.assertAll
+import org.junit.jupiter.api.Test
+import wordle.infra.dictionaryWordsSize
+
+private const val CONTAINS_WORD = "hello"
+
+class DictionaryKtTest {
+    @Test
+    fun `(성공) 사전에 포함된 문자열인지 확인할 수 있다`() {
+        val notInWord = "abced"
+
+        assertAll(
+            { assertThat(isDictionaryWord(CONTAINS_WORD)).isTrue() },
+            { assertThat(isDictionaryWord(notInWord)).isFalse() },
+        )
+    }
+
+    @Test
+    fun `(성공) 사전 안의 단어목록 중 인덱스에 해당하는 문자열을 가져온다`() {
+        val index = 0
+
+        assertThat(dictionaryElementAt(index)).isEqualTo(CONTAINS_WORD)
+    }
+
+    @Test
+    fun `(성공) 단어 목록 인덱스의 최댓값보다 큰 인덱스를 입력하면 단어 목록의 인덱스는 다시 0부터 시작한다`() {
+        val index = dictionaryWordsSize
+
+        assertThat(dictionaryElementAt(index)).isEqualTo(CONTAINS_WORD)
+    }
+}
diff --git a/src/test/kotlin/wordle/domain/LetterTest.kt b/src/test/kotlin/wordle/domain/LetterTest.kt
new file mode 100644
index 0000000..465b743
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/LetterTest.kt
@@ -0,0 +1,42 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+
+class LetterTest {
+    @Test
+    fun `(성공) 알파벳 소문자 글자를 생성한다`() {
+        val actual = Letter('a')
+
+        assertThat(actual).isEqualTo(Letter('a'))
+    }
+
+    @Test
+    fun `(성공) 일치 표시 기호를 생성한다`() {
+        val actual = Letter(MATCH_MARKER)
+
+        assertThat(actual).isEqualTo(Letter(MATCH_MARKER))
+    }
+
+    @ValueSource(strings = [" ", "1", "A", "나", "@"])
+    @ParameterizedTest
+    fun `(예외) 유효하지 않은 글자를 생성하면 예외 발생한다`(letter: Char) {
+        assertThatThrownBy { (Letter(letter)) }
+            .isInstanceOf(IllegalStateException::class.java)
+            .hasMessage("유효하지 않은 글자 형식입니다.")
+    }
+
+    @Test
+    fun `(성공) 체크 표시 글자로 변경한다`() {
+        val letter = Letter('b')
+
+        val actual = letter.changeMatchMarker()
+
+        assertThat(actual).isEqualTo(Letter(MATCH_MARKER))
+    }
+}
+
+private const val MATCH_MARKER = '#'
diff --git a/src/test/kotlin/wordle/domain/TodayWordTest.kt b/src/test/kotlin/wordle/domain/TodayWordTest.kt
new file mode 100644
index 0000000..41dc53b
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/TodayWordTest.kt
@@ -0,0 +1,30 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import java.time.LocalDate
+
+class TodayWordTest {
+    @Test
+    fun `(성공) 오늘의 단어는 오늘 날짜를 입력받아 단어를 생성한다`() {
+        val today = LocalDate.of(2021, 6, 19)
+
+        val actual = TodayWord(today)
+
+        assertThat(actual).isEqualTo(Word("hello"))
+    }
+
+    @Test
+    fun `(성공) 오늘의 단어는 매일 바뀐다`() {
+        val criterionDate = LocalDate.of(2024, 6, 17)
+        val wordsSet = mutableSetOf<Word>()
+
+        repeat(365) {
+            val currentDate = criterionDate.plusDays(it.toLong())
+            val word = TodayWord(currentDate)
+            wordsSet.add(word)
+        }
+
+        assertThat(wordsSet).hasSize(365)
+    }
+}
diff --git a/src/test/kotlin/wordle/domain/TryCountTest.kt b/src/test/kotlin/wordle/domain/TryCountTest.kt
new file mode 100644
index 0000000..3bb8898
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/TryCountTest.kt
@@ -0,0 +1,65 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertAll
+import org.junit.jupiter.api.assertDoesNotThrow
+
+class TryCountTest {
+    @Test
+    fun `시도 가능 횟수를 생성한다 - 최대 시도 가능 횟수를 가진다`() {
+        val actual = TryCount()
+
+        assertThat(actual).isEqualTo(TryCount(MAX_TRY_COUNT))
+    }
+
+    @Test
+    fun `시도한 횟수를 반환한다`() {
+        val tryCount = TryCount()
+
+        val actual = tryCount.attempts
+
+        assertThat(actual).isZero()
+    }
+
+    @Test
+    fun `시도 가능 횟수가 있다면 true 를 반환한다`() {
+        val tryCount = TryCount()
+        tryCount.minus()
+
+        val actual = tryCount.isRemainder()
+
+        assertThat(actual).isTrue()
+    }
+
+    @Test
+    fun `시도 가능 횟수가 없다면 false 를 반환한다`() {
+        val tryCount = TryCount(0)
+
+        val actual = tryCount.isRemainder()
+
+        assertThat(actual).isFalse()
+    }
+
+    @Test
+    fun `시도 가능 횟수를 1회 차감하면 시도한 횟수는 1회 증가한다`() {
+        val tryCount = TryCount(6)
+
+        assertDoesNotThrow { tryCount.minus() }
+
+        assertAll(
+            { assertThat(tryCount).isEqualTo(TryCount(5)) },
+            { assertThat(tryCount.attempts).isEqualTo(1) },
+        )
+    }
+
+    @Test
+    fun `시도 가능 횟수가 0 보다 작으면, 예외를 반환한다`() {
+        val tryCount = TryCount(0)
+
+        assertThatThrownBy { tryCount.minus() }
+            .isInstanceOf(IllegalStateException::class.java)
+            .hasMessage("시행 횟수는 0보다 작을 수 없습니다.")
+    }
+}
diff --git a/src/test/kotlin/wordle/domain/WordResultTest.kt b/src/test/kotlin/wordle/domain/WordResultTest.kt
new file mode 100644
index 0000000..2be2609
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/WordResultTest.kt
@@ -0,0 +1,55 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertAll
+
+class WordResultTest {
+    @Test
+    fun `(성공) 단어 결과는 글자 일치 상태 목록 없이 생성할 수 있다 - 모두 '불일치 상태'를 가진다`() {
+        val wordResult = WordResult()
+
+        assertThat(wordResult).isEqualTo(MutableList(WORD_LENGTH) { LetterMatch.ABSENT }.toWordResult())
+    }
+
+    @Test
+    fun `(성공) 해당 글자의 글자 일치 상태를 변경할 수 있다`() {
+        val wordResult = WordResult()
+
+        wordResult.changeMatchType(0, LetterMatch.CORRECT)
+        wordResult.changeMatchType(2, LetterMatch.PRESENT)
+        wordResult.changeMatchType(4, LetterMatch.CORRECT)
+
+        assertThat(wordResult).isEqualTo(
+            mutableListOf(
+                LetterMatch.CORRECT,
+                LetterMatch.ABSENT,
+                LetterMatch.PRESENT,
+                LetterMatch.ABSENT,
+                LetterMatch.CORRECT,
+            ).toWordResult(),
+        )
+    }
+
+    @Test
+    fun `(성공) 해당 글자가 '완전 일치 상태'인지 확인한다`() {
+        val wordResult = WordResult()
+
+        wordResult.changeMatchType(1, LetterMatch.CORRECT)
+
+        assertAll(
+            { assertThat(wordResult.isCorrectLetterMatch(0)).isFalse() },
+            { assertThat(wordResult.isCorrectLetterMatch(1)).isTrue() },
+        )
+    }
+
+    @Test
+    fun `(예외) 단어 결과 목록이 단어 길이와 일치헤야 한다`() {
+        assertThatThrownBy { WordResult(mutableListOf()) }
+            .isInstanceOf(IllegalStateException::class.java)
+            .hasMessage("단어 결과의 글자 일치 상태 목록들은 단어 길이인 ${WORD_LENGTH}와 일치해야 합니다.")
+    }
+}
+
+fun MutableList<LetterMatch>.toWordResult(): WordResult = WordResult(this)
diff --git a/src/test/kotlin/wordle/domain/WordResultsTest.kt b/src/test/kotlin/wordle/domain/WordResultsTest.kt
new file mode 100644
index 0000000..bbeeacb
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/WordResultsTest.kt
@@ -0,0 +1,107 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.jupiter.api.Assertions.assertAll
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+
+class WordResultsTest {
+    @Test
+    fun `(성공) 단어 결과 목록은 빈 단어 결과 목록과 시도한 횟수가 0이다`() {
+        val actual = WordResults()
+
+        assertAll(
+            { assertThat(actual.wordResults()).hasSize(0) },
+            { assertThat(actual.attemptCount).isZero() },
+        )
+    }
+
+    @Test
+    fun `(성공) 단어 결과 목록은 단어 결과를 추가하고, 시도횟수가 1회 증가한다`() {
+        val wordResults = WordResults()
+
+        wordResults.addResults(WordResult())
+
+        assertAll(
+            { assertThat(wordResults.wordResults()).hasSize(1) },
+            { assertThat(wordResults.attemptCount).isEqualTo(1) },
+        )
+    }
+
+    @ValueSource(ints = [1, 2, 3, 4, 5])
+    @ParameterizedTest
+    fun `(성공) 단어 결과 목록을 추가할 때마다 게임을 계속 진행할 수 있는 상태인지 반환한다`(attemptCount: Int) {
+        val wordResults = WordResults()
+
+        repeat(attemptCount) {
+            wordResults.addResults(WordResult())
+        }
+
+        assertThat(wordResults.isContinuousGame()).isTrue()
+    }
+
+    @Test
+    fun `(성공) 단어 결과 목록이 최대로 추가되었을 때 게임을 계속할 수 없는 상태가 된다`() {
+        val wordResults = WordResults()
+
+        repeat(MAX_TRY_COUNT) {
+            wordResults.addResults(WordResult())
+        }
+
+        assertThat(wordResults.isContinuousGame()).isFalse()
+    }
+
+    @Test
+    fun `(예외) 단어 결과 목록을 더이상 추가할 수 없으면 예외가 발생한다`() {
+        val wordResults = WordResults()
+
+        assertThatThrownBy {
+            repeat(MAX_TRY_COUNT + 1) {
+                wordResults.addResults(WordResult())
+            }
+        }.isInstanceOf(IllegalStateException::class.java)
+            .hasMessage("시행 횟수는 0보다 작을 수 없습니다.")
+    }
+
+    @Test
+    fun `(성공) 단어 결과 목록 마지막에 모두 '완전 일치 상태'가 있어야 단어 맞추기 게임에 성공한다`() {
+        val wordResults = WordResults()
+        wordResults.addResults(WordResult())
+        wordResults.addResults(oneAbsentWordResult)
+        wordResults.addResults(onePresentWordResult)
+        wordResults.addResults(MutableList(WORD_LENGTH) { LetterMatch.CORRECT }.toWordResult())
+
+        assertThat(wordResults.isSuccessfulGame()).isTrue()
+    }
+
+    @Test
+    fun `(성공) 단어 결과가 모두 '완전 일치 상태'가 아니면 단어 맞추기 게임에 성공여부가 False이다`() {
+        val wordResults = WordResults()
+        wordResults.addResults(oneAbsentWordResult)
+        wordResults.addResults(oneAbsentWordResult)
+        wordResults.addResults(oneAbsentWordResult)
+        wordResults.addResults(onePresentWordResult)
+
+        assertThat(wordResults.isSuccessfulGame()).isFalse()
+    }
+
+    private val oneAbsentWordResult =
+        mutableListOf(
+            LetterMatch.ABSENT,
+            LetterMatch.CORRECT,
+            LetterMatch.CORRECT,
+            LetterMatch.CORRECT,
+            LetterMatch.CORRECT,
+        ).toWordResult()
+
+    private val onePresentWordResult =
+        mutableListOf(
+            LetterMatch.PRESENT,
+            LetterMatch.CORRECT,
+            LetterMatch.CORRECT,
+            LetterMatch.CORRECT,
+            LetterMatch.CORRECT,
+        ).toWordResult()
+}
diff --git a/src/test/kotlin/wordle/domain/WordTest.kt b/src/test/kotlin/wordle/domain/WordTest.kt
new file mode 100644
index 0000000..b4b419c
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/WordTest.kt
@@ -0,0 +1,42 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.EmptySource
+import org.junit.jupiter.params.provider.ValueSource
+
+class WordTest {
+    @Test
+    fun `(성공) 단어를 생성한다`() {
+        val actual = Word("hello")
+
+        assertThat(actual).isEqualTo(Word("hello"))
+    }
+
+    @EmptySource
+    @ValueSource(strings = [" ", "     "])
+    @ParameterizedTest
+    fun `(예외) 단어는 공백만 입력할 수 없다`(invalidWord: String) {
+        assertThatThrownBy { (Word(invalidWord)) }
+            .isInstanceOf(IllegalStateException::class.java)
+            .hasMessage("단어는 공백만 입력할 수 없습니다.")
+    }
+
+    @ValueSource(strings = ["word", "aaaaaa"])
+    @ParameterizedTest
+    fun `(예외) 단어의 길이는 5자 이어야 한다`(invalidWord: String) {
+        assertThatThrownBy { (Word(invalidWord)) }
+            .isInstanceOf(IllegalStateException::class.java)
+            .hasMessage("단어의 길이는 ${WORD_LENGTH}자 입니다.")
+    }
+
+    @ValueSource(strings = ["aaaaa", "abced"])
+    @ParameterizedTest
+    fun `(예외) 단어는 사전에 있는 단어이어야 한다`(invalidWord: String) {
+        assertThatThrownBy { (Word(invalidWord)) }
+            .isInstanceOf(IllegalStateException::class.java)
+            .hasMessage("Wordle Game에서 유효한 단어가 아닙니다.")
+    }
+}
diff --git a/src/test/kotlin/wordle/domain/WordleGameLogicTest.kt b/src/test/kotlin/wordle/domain/WordleGameLogicTest.kt
new file mode 100644
index 0000000..5fa5127
--- /dev/null
+++ b/src/test/kotlin/wordle/domain/WordleGameLogicTest.kt
@@ -0,0 +1,188 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Nested
+import org.junit.jupiter.api.Test
+
+class WordleGameLogicTest {
+    private lateinit var wordleGameLogic: WordleGameLogic
+
+    @BeforeEach
+    fun setUp() {
+        val todayWord = Word("spill")
+        wordleGameLogic = WordleGameLogic(todayWord)
+    }
+
+    @Nested
+    inner class `단어 결과 중 글자 일치 상태가 하나만 다른 경우` {
+        @Test
+        fun `(성공) 하나의 글자 결과만 '부분 일치 글자'일 때 비교한다`() {
+            val answerWord = Word("proxy")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(
+                mutableListOf(
+                    LetterMatch.PRESENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                ).toWordResult(),
+            )
+        }
+
+        @Test
+        fun `(성공) 하나의 글자 결과만 '완전 일치 글자'일 때 비교한다 - '완전 일치 글자'부터 비교한다`() {
+            val answerWord = Word("royal")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(
+                mutableListOf(
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.CORRECT,
+                ).toWordResult(),
+            )
+        }
+    }
+
+    @Nested
+    inner class `답안 단어에 같은 글자가 있는 경우` {
+        @Test
+        fun `(성공) 두 번 같은 글자가 연속되는 답안 단어에서, 오늘의 단어와 한 글자만 '부분 일치 글자'일 때 비교한다`() {
+            val answerWord = Word("truss")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(
+                mutableListOf(
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.PRESENT,
+                    LetterMatch.ABSENT,
+                ).toWordResult(),
+            )
+        }
+
+        @Test
+        fun `(성공) 두 번 같은 글자가 연속되는 답안 단어에서, 오늘의 단어와 두 글자 '부분 일치 글자'일 때 비교한다`() {
+            val answerWord = Word("llama")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(
+                mutableListOf(
+                    LetterMatch.PRESENT,
+                    LetterMatch.PRESENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                ).toWordResult(),
+            )
+        }
+
+        @Test
+        fun `(성공) 두 번 같은 글자가 연속되는 답안 단어에서, '부분 일치 글자'와 '완전 일치 글자'를 가질 때 비교한다`() {
+            val answerWord = Word("hello")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(
+                mutableListOf(
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.PRESENT,
+                    LetterMatch.CORRECT,
+                    LetterMatch.ABSENT,
+                ).toWordResult(),
+            )
+        }
+
+        @Test
+        fun `(성공) 같은 글자가 연속 하지 않는 답안 단어에서, '부분 일치 글자'와 '완전 일치 글자'를 가질 때 비교한다`() {
+            val answerWord = Word("label")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(
+                mutableListOf(
+                    LetterMatch.PRESENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.CORRECT,
+                ).toWordResult(),
+            )
+        }
+
+        @Test
+        fun `(성공) 세 개의 같은 글자를 가지는 답안 단어에서 하나의 글자 결과만 '부분 일치 글자'일 때 비교한다`() {
+            val answerWord = Word("puppy")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(
+                mutableListOf(
+                    LetterMatch.PRESENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.ABSENT,
+                ).toWordResult(),
+            )
+        }
+
+        @Test
+        fun `(성공) 네 개의 글자 결과가 '완전 일치 글자'일 때 비교한다`() {
+            val answerWord = Word("spell")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(
+                mutableListOf(
+                    LetterMatch.CORRECT,
+                    LetterMatch.CORRECT,
+                    LetterMatch.ABSENT,
+                    LetterMatch.CORRECT,
+                    LetterMatch.CORRECT,
+                ).toWordResult(),
+            )
+        }
+    }
+
+    @Nested
+    inner class `단어 결과 중 글자 일치 상태가 모두 같은 경우` {
+        @Test
+        fun `(성공) 모든 글자 결과가 '불일치 상태'일 때 비교한다`() {
+            val answerWord = Word("major")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(MutableList(WORD_LENGTH) { LetterMatch.ABSENT }.toWordResult())
+        }
+
+        @Test
+        fun `(성공) 모든 글자 결과가 '부분 일치 글자'일 때 비교한다`() {
+            val answerWord = Word("illps")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(MutableList(WORD_LENGTH) { LetterMatch.PRESENT }.toWordResult())
+        }
+
+        @Test
+        fun `(성공) 모든 글자 결과가 '완전 일치 글자'일 때 비교한다`() {
+            val answerWord = Word("spill")
+
+            val result = wordleGameLogic.compare(answerWord)
+
+            assertThat(result).isEqualTo(MutableList(WORD_LENGTH) { LetterMatch.CORRECT }.toWordResult())
+        }
+    }
+}
diff --git a/src/test/resources/words.txt b/src/test/resources/words.txt
new file mode 100644
index 0000000..2015d7d
--- /dev/null
+++ b/src/test/resources/words.txt
@@ -0,0 +1,371 @@
+hello
+spill
+cigar
+rebut
+sissy
+humph
+awake
+blush
+focal
+evade
+naval
+serve
+heath
+dwarf
+model
+karma
+stink
+grade
+quiet
+bench
+abate
+feign
+major
+death
+fresh
+crust
+stool
+colon
+abase
+marry
+react
+batty
+pride
+floss
+helix
+croak
+staff
+paper
+unfed
+whelp
+trawl
+outdo
+adobe
+crazy
+sower
+repay
+digit
+crate
+cluck
+spike
+mimic
+pound
+maxim
+linen
+unmet
+flesh
+booby
+forth
+first
+stand
+belly
+ivory
+seedy
+print
+yearn
+drain
+bribe
+stout
+panel
+crass
+flume
+offal
+agree
+error
+swirl
+argue
+bleed
+delta
+flick
+totem
+wooer
+front
+shrub
+parry
+biome
+lapel
+start
+greet
+goner
+golem
+lusty
+loopy
+round
+audit
+lying
+gamma
+labor
+islet
+civic
+forge
+corny
+moult
+basic
+salad
+agate
+spicy
+spray
+essay
+fjord
+spend
+kebab
+guild
+aback
+motor
+alone
+hatch
+hyper
+thumb
+dowry
+ought
+belch
+dutch
+pilot
+tweed
+comet
+jaunt
+enema
+steed
+abyss
+growl
+fling
+dozen
+boozy
+erode
+world
+gouge
+click
+briar
+great
+altar
+pulpy
+blurt
+coast
+duchy
+groin
+fixer
+group
+rogue
+badly
+smart
+pithy
+gaudy
+chill
+heron
+vodka
+finer
+surer
+radio
+rouge
+perch
+retch
+wrote
+clock
+tilde
+store
+prove
+bring
+solve
+cheat
+grime
+exult
+usher
+epoch
+triad
+break
+rhino
+viral
+conic
+masse
+sonic
+vital
+trace
+using
+peach
+champ
+baton
+brake
+pluck
+craze
+gripe
+weary
+picky
+acute
+ferry
+aside
+tapir
+troll
+unify
+rebus
+boost
+truss
+siege
+tiger
+banal
+slump
+crank
+gorge
+query
+drink
+favor
+abbey
+tangy
+panic
+solar
+shire
+proxy
+point
+robot
+prick
+wince
+crimp
+knoll
+sugar
+whack
+mount
+perky
+could
+wrung
+light
+those
+moist
+shard
+pleat
+aloft
+skill
+elder
+frame
+humor
+pause
+ulcer
+ultra
+robin
+cynic
+aroma
+caulk
+shake
+dodge
+swill
+tacit
+other
+thorn
+trove
+bloke
+vivid
+chant
+choke
+rupee
+nasty
+mourn
+ahead
+brine
+cloth
+hoard
+sweet
+month
+lapse
+watch
+today
+focus
+smelt
+tease
+cater
+movie
+saute
+allow
+renew
+their
+slosh
+purge
+chest
+depot
+epoxy
+nymph
+found
+shall
+harry
+stove
+lowly
+snout
+trope
+fewer
+shawl
+natal
+comma
+foray
+scare
+stair
+black
+squad
+royal
+chunk
+mince
+shame
+cheek
+ample
+flair
+foyer
+cargo
+oxide
+plant
+olive
+inert
+askew
+heist
+shown
+zesty
+hasty
+trash
+fella
+larva
+forgo
+story
+hairy
+train
+homer
+badge
+midst
+canny
+fetus
+butch
+farce
+slung
+tipsy
+metal
+yield
+delve
+being
+scour
+glass
+gamer
+scrap
+money
+hinge
+album
+vouch
+asset
+tiara
+crept
+bayou
+atoll
+manor
+creak
+showy
+phase
+froth
+depth
+gloom
+flood
+trait
+girth
+piety
+payer
+goose
+float
+donor
+atone
+label
+spell
+llama
+puppy
+illps