diff --git a/README.md b/README.md
index d3179421..903ed09c 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,10 @@
 # 미션 - 워들
 
+## 🙆🏻‍♀️페어 구성🙆🏻
+- 점프
+- 얄뭉
+---
+
 ## 🔍 진행 방식
 
 - 미션은 **과제 진행 요구 사항**, **기능 요구 사항**, **프로그래밍 요구 사항** 세 가지로 구성되어 있다.
@@ -12,13 +17,16 @@
 
 선풍적인 인기를 끌었던 영어 단어 맞추기 게임이다.
 
-- 6x5 격자를 통해서 5글자 단어를 6번 만에 추측한다.
-- 플레이어가 답안을 제출하면 프로그램이 정답과 제출된 단어의 각 알파벳 종류와 위치를 비교해 판별한다.
-- 판별 결과는 흰색의 타일이 세 가지 색(초록색/노란색/회색) 중 하나로 바뀌면서 표현된다.
-    - 맞는 글자는 초록색, 위치가 틀리면 노란색, 없으면 회색
+- [x] 게임 진행 메시지를 출력한다.
+- [x] 격자를 통해서 5글자 단어를 6번 만에 추측한다.
+- [x] 플레이어가 답안을 제출하면 프로그램이 정답과 제출된 단어의 각 알파벳 종류와 위치를 비교해 판별한다.
+  - [x] 입력 단어는 영단어야 한다.
+  - [x] 단어의 수는 5글자여야 한다.
+  - [x] 단어는 `words.txt`에 포함된 단어여야 한다.
+- [x] 판별 결과는 흰색의 타일이 세 가지 색(초록색/노란색/회색) 중 하나로 바뀌면서 표현된다.
+    - 맞는 글자는 초록색(🟩), 위치가 틀리면 노란색(🟨), 없으면 회색(⬜)
     - 두 개의 동일한 문자를 입력하고 그중 하나가 회색으로 표시되면 해당 문자 중 하나만 최종 단어에 나타난다.
-- 정답과 답안은 `words.txt`에 존재하는 단어여야 한다.
-- 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
+- [x] 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
 
 ### 입출력 요구 사항
 
@@ -87,3 +95,36 @@ spill
 - 도메인 로직에 단위 테스트를 구현해야 한다. 단, UI(System.out, System.in, Scanner) 로직은 제외한다.
     - 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 분리해 구현한다.
     - 힌트: MVC 패턴 기반으로 구현한 후, View와 Controller를 제외한 Model에 대한 단위 테스트 추가에 집중한다.
+---
+### 구현 목록
+- 단어 불러오기
+- 매일 바뀌는 정답단어 선택
+- 단어 입력
+  - 입력시 단어목록에 있나 검증
+- 비교 로직
+  - 같을때, 있을떄, 없을때 따른 비교결과
+- 게임로직
+  - 6회 초과시 게임오버
+  - 정답시 게임클리어
+- ui
+  - 비교 결과, 라운드 출력
+
+---
+### 리팩터링 포인트
+- [x] final 붙혀주기
+- [x] Inputword 에 availableWords 상태로 가지고 있을 필요는 없다.
+- [x] InputWord와 Answer를 합치기?
+- [x] match 에 for 문안 함수로 발라내기
+- [x] isEndGame 플래그 변수 네이밍 변경
+  - [x] 검증
+  - [x] 5글자 검증
+- [x] 영단어 검증
+- [x] 예외 try catch
+- [x] GameManager에 있는 List 의 변수명 변경
+- [x] HintView에 3depth 줄이기
+- [x] InputWord의 마지막 테스트함수 이름
+- [x] MatchResult에 inputChar가 쓰이지 않고 있어서 클래스 자체를 지우고 그냥 Hint만 쓰기
+- ~~- 구조 변경~~
+  - ~~-  GameManager의 의존성 줄여두기~~
+  - ~~-String 말고 char 배열로 쓸지? -> 좀 더 고민해보기~~
+  - ~~-분리된 view 부분 합칠지?~~
diff --git a/src/main/java/WordleApplication.java b/src/main/java/WordleApplication.java
new file mode 100644
index 00000000..6bfdff82
--- /dev/null
+++ b/src/main/java/WordleApplication.java
@@ -0,0 +1,15 @@
+import config.FileConfig;
+import controller.GameManager;
+import infra.WordLoader;
+
+import java.util.List;
+
+public class WordleApplication {
+    public static void main(String[] args) {
+
+        List<String> words = WordLoader.read(FileConfig.FILE_PATH);
+        GameManager gameManager = new GameManager(words);
+        gameManager.start();
+    }
+
+}
diff --git a/src/main/java/config/FileConfig.java b/src/main/java/config/FileConfig.java
new file mode 100644
index 00000000..9eebf506
--- /dev/null
+++ b/src/main/java/config/FileConfig.java
@@ -0,0 +1,8 @@
+package config;
+
+public class FileConfig {
+
+    protected FileConfig() {
+    }
+    public static final String FILE_PATH = "src/main/resources/words.txt";
+}
diff --git a/src/main/java/controller/GameManager.java b/src/main/java/controller/GameManager.java
new file mode 100644
index 00000000..9ce6b27f
--- /dev/null
+++ b/src/main/java/controller/GameManager.java
@@ -0,0 +1,86 @@
+package controller;
+
+import domain.MatchResult;
+import domain.MatchResults;
+import domain.Round;
+import domain.Word;
+import ui.GuideTextView;
+import ui.HintView;
+import ui.InputView;
+import ui.RoundView;
+
+import java.time.LocalDate;
+import java.util.List;
+
+public class GameManager {
+
+    private final static int LIMIT = 6;
+    private final static int CURRENT = 1;
+    private final Round round;
+    private final MatchResults matchResults;
+    private final Word answer;
+    private final GuideTextView guideTextView;
+    private final InputView inputView;
+    private final HintView hintView;
+    private final RoundView roundView;
+    private final List<String> availableWords;
+    private boolean isWinning = false;
+
+    public GameManager(List<String> availableWords) {
+        this.answer = Word.createAnswer(LocalDate.now(), availableWords);
+        this.availableWords = availableWords;
+        this.round = new Round(LIMIT, CURRENT);
+        this.matchResults = new MatchResults();
+        this.guideTextView = new GuideTextView();
+        this.inputView = new InputView();
+        this.hintView = new HintView();
+        this.roundView = new RoundView();
+    }
+    public void start() {
+        guideTextView.render();
+        while(!this.isWinning && round.isNotFinalRound()) {
+            startRound();
+        }
+    }
+
+    private void startRound() {
+        Word inputWord = null;
+        boolean canCreateInputWord = false;
+
+        while (!canCreateInputWord) {
+            String input = inputView.input();
+            inputWord = Word.createInput(input, this.availableWords);
+            canCreateInputWord = inputWord.getAvailableWord();
+        }
+
+        checkAnswer(inputWord);
+        renderResult();
+        round.goNext();
+    }
+
+    private void renderResult() {
+        checkRenderRound();
+        hintView.render(matchResults);
+        checkFinalRound();
+    }
+
+    private void checkRenderRound() {
+        if(this.isWinning || !round.isNotFinalRound()) {
+            roundView.render(round.getCurrent(),round.getLimit());
+        }
+    }
+
+    private void checkFinalRound() {
+        if(!this.isWinning && round.isFinalRound()) {
+            roundView.render(round.getCurrent(),round.getLimit());
+            roundView.renderLoseGame();;
+        }
+    }
+
+    private void checkAnswer(Word inputWord) {
+        MatchResult matchResultOfInput = answer.match(inputWord);
+        this.matchResults.add(matchResultOfInput);
+        this.isWinning = matchResultOfInput.isEndGame();
+    }
+
+}
diff --git a/src/main/java/domain/Hint.java b/src/main/java/domain/Hint.java
new file mode 100644
index 00000000..71565059
--- /dev/null
+++ b/src/main/java/domain/Hint.java
@@ -0,0 +1,20 @@
+package domain;
+
+public enum Hint {
+    CORRECT("🟩"),           // \uD83D\uDFE9
+    EXIST("🟨"),             // \uD83D\uDFE8
+    NOT_EXIST("⬜");
+    private final String tile;
+
+    Hint(String tile) {
+        this.tile = tile;
+    }
+
+    public String getTile() {
+        return tile;
+    }
+
+    public static boolean isCorrect(Hint hint) {
+        return Hint.CORRECT.equals(hint);
+    }
+}
diff --git a/src/main/java/domain/HintLetter.java b/src/main/java/domain/HintLetter.java
new file mode 100644
index 00000000..fc4a131f
--- /dev/null
+++ b/src/main/java/domain/HintLetter.java
@@ -0,0 +1,44 @@
+package domain;
+
+import java.util.List;
+import java.util.Objects;
+
+public class HintLetter {
+    private final Character letter;
+
+    private Hint hint;
+
+    public HintLetter(Character letter, Hint hint) {
+        this.letter = letter;
+        this.hint = hint;
+    }
+
+    public void changeCorrectToNotExist(List<Character> correctedChar) {
+        if(correctedChar.contains(letter) && !isCorrectHint()) {
+            this.hint = Hint.NOT_EXIST;
+        }
+    }
+
+    public boolean isCorrectHint() {
+        return Hint.isCorrect(hint);
+    }
+
+    public String getHintTile() {
+        return hint.getTile();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        HintLetter that = (HintLetter) o;
+        return Objects.equals(letter, that.letter) && hint == that.hint;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(letter, hint);
+    }
+}
+
+
diff --git a/src/main/java/domain/MatchResult.java b/src/main/java/domain/MatchResult.java
new file mode 100644
index 00000000..a848a04e
--- /dev/null
+++ b/src/main/java/domain/MatchResult.java
@@ -0,0 +1,42 @@
+package domain;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class MatchResult {
+    private final List<HintLetter> hints;
+    public MatchResult(List<HintLetter> hints) {
+        this.hints = hints;
+    }
+
+    public boolean isEndGame() {
+        return hints.stream()
+                .allMatch(HintLetter::isCorrectHint);
+    }
+    public void add(HintLetter hintLetter) {
+        hints.add(hintLetter);
+    }
+
+    public String getHintTiles() {
+        return hints.stream()
+                .map(HintLetter::getHintTile)
+                .collect(Collectors.joining());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        MatchResult that = (MatchResult) o;
+        return Objects.equals(hints, that.hints);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(hints);
+    }
+}
+
+
diff --git a/src/main/java/domain/MatchResults.java b/src/main/java/domain/MatchResults.java
new file mode 100644
index 00000000..ad14cbfc
--- /dev/null
+++ b/src/main/java/domain/MatchResults.java
@@ -0,0 +1,19 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class MatchResults implements Iterable<MatchResult> {
+    private final List<MatchResult> results;
+    public MatchResults() {
+        this.results = new ArrayList<>();
+    }
+    public void add(MatchResult matchResultOfInput) {
+        this.results.add(matchResultOfInput);
+    }
+    @Override
+    public Iterator<MatchResult> iterator() {
+        return this.results.iterator();
+    }
+}
diff --git a/src/main/java/domain/Round.java b/src/main/java/domain/Round.java
new file mode 100644
index 00000000..668e2512
--- /dev/null
+++ b/src/main/java/domain/Round.java
@@ -0,0 +1,31 @@
+package domain;
+
+public class Round {
+    private final int limit;
+    private int current;
+
+    public Round(int limit, int current) {
+        this.limit = limit;
+        this.current = current;
+    }
+
+    public void goNext() {
+        this.current++;
+    }
+
+    public int getLimit() {
+        return limit;
+    }
+
+    public int getCurrent() {
+        return current;
+    }
+
+    public boolean isNotFinalRound() {
+        return current <= limit;
+    }
+
+    public boolean isFinalRound() {
+        return current == limit;
+    }
+}
diff --git a/src/main/java/domain/Word.java b/src/main/java/domain/Word.java
new file mode 100644
index 00000000..970a76b0
--- /dev/null
+++ b/src/main/java/domain/Word.java
@@ -0,0 +1,141 @@
+package domain;
+
+import java.time.LocalDate;
+import java.time.Period;
+import java.util.*;
+import java.util.stream.Stream;
+
+public class Word {
+    private final static int MAX_LENGTH = 5;
+    private final String value;
+    private final boolean availableWord;
+
+    public Word(String value) {
+        this.value = value;
+        this.availableWord = true;
+    }
+
+    public Word(String value, boolean availableWord) {
+        this.value = value;
+        this.availableWord = availableWord;
+    }
+
+    public static Word createAnswer(LocalDate currentDate, List<String> availableWords) {
+        LocalDate fixedDate = LocalDate.of(2021, 6, 19);
+        int diffDay = Period.between(fixedDate, currentDate).getDays();
+        int index = diffDay % availableWords.size();
+
+        return new Word(availableWords.get(index));
+    }
+
+    public static Word createInput(String value, List<String> availableWords) {
+        boolean availableWord = isValidate(value, availableWords);
+        return new Word(value, availableWord);
+    }
+
+    public MatchResult match(Word word) {
+        List<Character> correctedChar = new ArrayList<>();
+
+        List<HintLetter> hintLetters = getHintLetters(word, correctedChar);
+        hintLetters.forEach(hintLetter -> hintLetter.changeCorrectToNotExist(correctedChar));
+
+        return new MatchResult(hintLetters);
+    }
+
+    public boolean getAvailableWord() {
+        return availableWord;
+    }
+
+    private List<HintLetter> getHintLetters(Word word, List<Character> correctedChar) {
+        return Stream.iterate(0, i -> i + 1)
+                .limit(value.length())
+                .map(i -> getHintLetter(word, i, correctedChar))
+                .toList();
+    }
+
+
+    private HintLetter getHintLetter(Word word, Integer i, List<Character> correctedChar) {
+        Hint hint = getHint(word, i);
+
+        if (Hint.isCorrect(hint)) {
+            correctedChar.add(word.getChar(i));
+        }
+
+        return new HintLetter(word.getChar(i), hint);
+    }
+
+
+    private Character getChar(int i) {
+        return value.charAt(i);
+    }
+
+    private Hint getHint(Word word, int index) {
+        char inputChar = word.getChar(index);
+
+        if (isCorrect(index, inputChar)) {
+            return Hint.CORRECT;
+        }
+
+        if (exists(inputChar)) {
+            return Hint.EXIST;
+        }
+        return Hint.NOT_EXIST;
+    }
+
+    private boolean exists(char inputChar) {
+        return value.indexOf(inputChar) != -1;
+    }
+
+    private boolean isCorrect(int index, char inputChar) {
+        return value.charAt(index) == inputChar;
+    }
+
+    private static boolean isValidate(String input, List<String> availableWords) {
+        if(isWrongLength(input)) {
+            return false;
+        }
+
+        if(notOnlyEnglish(input)) {
+            return false;
+        }
+
+        return !isNotContain(input, availableWords);
+    }
+
+    public static boolean notOnlyEnglish(String input) {
+        if (!input.matches("^[a-zA-Z]+$")) {
+            System.out.println("영단어를 입력해주세요. [" + input + "]");
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean isWrongLength(String input) {
+        if (input.length() != MAX_LENGTH) {
+            System.out.println(MAX_LENGTH + "자리의 단어를 입력해주세요.");
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean isNotContain(String input, List<String> availableWords) {
+        if (!availableWords.contains(input)) {
+            System.out.println("입력 불가능한 단어입니다.");
+            return true;
+        }
+        return false;
+    }
+
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Word word)) return false;
+        return getAvailableWord() == word.getAvailableWord() && Objects.equals(value, word.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value, getAvailableWord());
+    }
+}
diff --git a/src/main/java/infra/WordLoader.java b/src/main/java/infra/WordLoader.java
new file mode 100644
index 00000000..1fdf55d6
--- /dev/null
+++ b/src/main/java/infra/WordLoader.java
@@ -0,0 +1,19 @@
+package infra;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+
+public class WordLoader {
+    protected WordLoader() {
+    }
+
+    public static List<String> read(String filePath) {
+        try {
+            return Files.readAllLines(Paths.get(filePath));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
diff --git a/src/main/java/ui/GuideTextView.java b/src/main/java/ui/GuideTextView.java
new file mode 100644
index 00000000..3c6ef5a2
--- /dev/null
+++ b/src/main/java/ui/GuideTextView.java
@@ -0,0 +1,8 @@
+package ui;
+
+public class GuideTextView {
+    public void render() {
+        System.out.println("WORDLE을 6번 만에 맞춰 보세요.");
+        System.out.println("시도의 결과는 타일의 색 변화로 나타납니다.");
+    }
+}
diff --git a/src/main/java/ui/HintView.java b/src/main/java/ui/HintView.java
new file mode 100644
index 00000000..23f492ee
--- /dev/null
+++ b/src/main/java/ui/HintView.java
@@ -0,0 +1,15 @@
+package ui;
+
+import domain.MatchResult;
+import domain.MatchResults;
+
+public class HintView {
+    public void render(MatchResults matchResults) {
+        matchResults.forEach(HintView::drawTiles);
+    }
+
+    private static void drawTiles(MatchResult matchResultEachRound) {
+        System.out.print(matchResultEachRound.getHintTiles());
+        System.out.println();
+    }
+}
diff --git a/src/main/java/ui/InputView.java b/src/main/java/ui/InputView.java
new file mode 100644
index 00000000..f5e8e011
--- /dev/null
+++ b/src/main/java/ui/InputView.java
@@ -0,0 +1,13 @@
+package ui;
+
+import java.util.Scanner;
+
+public class InputView {
+    private final Scanner scanner = new Scanner(System.in);
+    public String input() {
+        System.out.println("정답을 입력해 주세요.");
+
+        return scanner.nextLine();
+    }
+
+}
diff --git a/src/main/java/ui/RoundView.java b/src/main/java/ui/RoundView.java
new file mode 100644
index 00000000..936e8e12
--- /dev/null
+++ b/src/main/java/ui/RoundView.java
@@ -0,0 +1,11 @@
+package ui;
+
+public class RoundView {
+    public void render(int current, int max) {
+        System.out.printf("%d/%d%n", current, max);
+    }
+
+    public void renderLoseGame() {
+        System.out.print("시도 가능 횟수가 종료되었습니다.");
+    }
+}
diff --git a/src/test/java/domain/AnswerTest.java b/src/test/java/domain/AnswerTest.java
new file mode 100644
index 00000000..01ebaa71
--- /dev/null
+++ b/src/test/java/domain/AnswerTest.java
@@ -0,0 +1,103 @@
+package domain;
+
+import infra.WordLoader;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class AnswerTest {
+    private final List<String> words = getWordList();
+    Word answer = Word.createAnswer(LocalDate.of(2021, 6, 20), words);
+
+
+    @ParameterizedTest
+    @ValueSource(strings = {"serve"})
+    @DisplayName("정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다")
+    void answerSelectTest(String input) {
+        assertThat(answer).isEqualTo(new Word(input));
+    }
+
+
+    @ParameterizedTest
+    @MethodSource("provideInputAnswer")
+    @DisplayName("입력단어와 정답 비교")
+    void matchTest(String input, List<HintLetter> hintLetters) {
+        Word inputWord = Word.createInput(input, words);
+        MatchResult matchResults = answer.match(inputWord);
+
+        MatchResult expected = new MatchResult(hintLetters);
+        assertThat(matchResults).isEqualTo(expected);
+    }
+
+
+    @ParameterizedTest
+    @MethodSource("provideLocationAnswer")
+    @DisplayName("입력단어와 중복 단어 위치 확인 테스트")
+    void matchLocationTest(String input, List<HintLetter> hintLetters) {
+        Word inputWord = Word.createInput(input, words);
+        MatchResult matchResults = answer.match(inputWord);
+
+        MatchResult expected = new MatchResult(hintLetters);
+        assertThat(matchResults).isEqualTo(expected);
+    }
+
+
+    private static List<String> getWordList() {
+        return WordLoader.read("src/test/resources/words.txt");
+    }
+
+
+    public static Stream<Object[]> provideInputAnswer() {
+        return Stream.of(
+                new Object[]{"serve", List.of(new HintLetter('s', Hint.CORRECT),
+                        new HintLetter('e', Hint.CORRECT),
+                        new HintLetter('r', Hint.CORRECT),
+                        new HintLetter('v', Hint.CORRECT),
+                        new HintLetter('e', Hint.CORRECT))},
+                new Object[]{"sssss", List.of(new HintLetter('s', Hint.CORRECT),
+                        new HintLetter('s', Hint.NOT_EXIST),
+                        new HintLetter('s', Hint.NOT_EXIST),
+                        new HintLetter('s', Hint.NOT_EXIST),
+                        new HintLetter('s', Hint.NOT_EXIST))},
+                new Object[]{"eeeee", List.of(new HintLetter('e', Hint.NOT_EXIST),
+                        new HintLetter('e', Hint.CORRECT),
+                        new HintLetter('e', Hint.NOT_EXIST),
+                        new HintLetter('e', Hint.NOT_EXIST),
+                        new HintLetter('e', Hint.CORRECT))},
+                new Object[]{"grade", List.of(new HintLetter('g', Hint.NOT_EXIST),
+                        new HintLetter('r', Hint.EXIST),
+                        new HintLetter('a', Hint.NOT_EXIST),
+                        new HintLetter('d', Hint.NOT_EXIST),
+                        new HintLetter('e', Hint.CORRECT))}
+        );
+    }
+
+    public static Stream<Object[]> provideLocationAnswer() {
+        return Stream.of(
+                new Object[]{"cigar", List.of(new HintLetter('c', Hint.NOT_EXIST),
+                        new HintLetter('i', Hint.NOT_EXIST),
+                        new HintLetter('g', Hint.NOT_EXIST),
+                        new HintLetter('a', Hint.NOT_EXIST),
+                        new HintLetter('r', Hint.EXIST))},
+                new Object[]{"sissy", List.of(new HintLetter('s', Hint.CORRECT),
+                        new HintLetter('i', Hint.NOT_EXIST),
+                        new HintLetter('s', Hint.NOT_EXIST),
+                        new HintLetter('s', Hint.NOT_EXIST),
+                        new HintLetter('y', Hint.NOT_EXIST))},
+                new Object[]{"naval", List.of(new HintLetter('n', Hint.NOT_EXIST),
+                        new HintLetter('a', Hint.NOT_EXIST),
+                        new HintLetter('v', Hint.EXIST),
+                        new HintLetter('a', Hint.NOT_EXIST),
+                        new HintLetter('l', Hint.NOT_EXIST))}
+        );
+    }
+}
diff --git a/src/test/java/domain/InputWordTest.java b/src/test/java/domain/InputWordTest.java
new file mode 100644
index 00000000..26de85e0
--- /dev/null
+++ b/src/test/java/domain/InputWordTest.java
@@ -0,0 +1,67 @@
+package domain;
+
+import infra.WordLoader;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+class InputWordTest {
+    private final List<String> words = getWordList();
+
+    @ParameterizedTest
+    @DisplayName("입력단어 유효성 검증 성공 테스트")
+    @MethodSource("provideContainedInputWords")
+    void validateSuccessInputWord(String input) {
+        assertTrue(words.contains(input));
+    }
+
+    @ParameterizedTest
+    @DisplayName("입력단어 유효성 검증 실패 테스트")
+    @ValueSource(strings = {"banana", "hello", "test", "world"})
+    void validateFailInputWord(String input) {
+        Word word = Word.createInput(input, words);
+        assertFalse(word.getAvailableWord());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"people"})
+    @DisplayName("입력단어 글자수 유효성 검증 실패 테스트")
+    void validateInputWordLength(String input) {
+        assertTrue(Word.isWrongLength(input));
+    }
+
+    @ParameterizedTest
+    @DisplayName("입력단어 영단어 유효성 검증 실패 테스트")
+    @MethodSource("provideWordsWithLength")
+    void validateInputWordOnlyEnglish(String input, boolean isRightWord) {
+        if (!isRightWord) {
+            Word word = Word.createInput(input, words);
+            assertFalse(word.getAvailableWord());
+        } else {
+            assertFalse(Word.notOnlyEnglish(input));
+        }
+    }
+
+    private static List<String> getWordList() {
+        return WordLoader.read("src/test/resources/words.txt");
+    }
+    private static Stream<String> provideContainedInputWords() {
+        return Stream.of("serve", "sssss", "eeeee", "naval");
+    }
+
+    public static Stream<Object[]> provideWordsWithLength() {
+        return Stream.of(
+                new Object[]{"안녕하세요", false},
+                new Object[]{"12345", false},
+                new Object[]{"serve", true}
+        );
+    }
+}
diff --git a/src/test/java/infra/WordLoaderTest.java b/src/test/java/infra/WordLoaderTest.java
new file mode 100644
index 00000000..7705c7f9
--- /dev/null
+++ b/src/test/java/infra/WordLoaderTest.java
@@ -0,0 +1,17 @@
+package infra;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class WordLoaderTest {
+    @Test
+    @DisplayName("단어목록파일 읽기")
+    void loadWordsFromFile(){
+        List<String> words = WordLoader.read("src/test/resources/words.txt");
+        assertThat(words).hasSize(18);
+    }
+}
diff --git a/src/test/resources/words.txt b/src/test/resources/words.txt
new file mode 100644
index 00000000..eecd8ac1
--- /dev/null
+++ b/src/test/resources/words.txt
@@ -0,0 +1,18 @@
+cigar
+serve
+sissy
+humph
+awake
+blush
+focal
+evade
+naval
+serve
+heath
+grade
+model
+rebut
+sssss
+eeeee
+people
+안녕하세요