diff --git a/README.md b/README.md
index b4b1377..da277b7 100644
--- a/README.md
+++ b/README.md
@@ -55,3 +55,33 @@ spill
 🟩🟩⬜🟩🟩
 🟩🟩🟩🟩🟩
 ```
+  
+## 요구사항  
+- [X] 하나의 Tile이 있다. => (Tile)
+  - [X] Tile에는 문자가 들어간다.
+    - [X] 알파벳만 입력이 가능하다.
+  - [X] Tile과 Tile은 비교할 수 있다.
+- [X] 여러개의 Tile을 묶는다. => (Tiles) (입력되어서 생성된 Tiles)
+  - [X] Tiles는 5글자를 받는다.
+  - [X] Tiles는 5개의 Tile로 구성이 되어있다.
+- [X] 정답이 있다. => (Answer)
+  - [X] Answer는 5글자를 받는다.
+  - [X] Answer는 5개의 Tile로 구성이 되어있다.
+  - [X] 정답과 비교하여 같은 위치에 있으면 GREEN이다
+  - [X] 정답에는 있지만 위치가 다르면 노란색
+  - [X] 아예 없으면 회색
+  - [X] 정답에 있는 타일은 n개이지만, 입력한 타일은 n + 1개 이상인 경우 초록 -> 노란색 -> 회색순으로 우선순위를 가진다
+- [X] 게임이 있다 => (Game)
+  - [X] 기회는 총 6번을 입력할 수 있다.
+  - [X] 정답을 적으면 게임이 끝난다.
+  - [X] 정답과 답안은 정답 저장소에 존재하는 단어여야 한다.
+    - [X] 존재하지 않는 단어이면 재입력을 한다. 
+  - [X] 결과를 전달할 수 있다.
+
+### PRESENTATION
+- [X] DefaultOutput
+  - [X] 새로운 문자를 적으면 과거에 있던 결과도 같이 표출된다.
+  - [X] 지금까지 입력한 Tiles를 가지고 있는다.
+- [X] DefaultWordsRepository
+  - [X] 정답과 답안은 `words.txt`에 존재하는 단어여야 한다.
+  - [X] 정답은 매일 바뀌며 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
\ No newline at end of file
diff --git a/src/main/kotlin/Application.kt b/src/main/kotlin/Application.kt
new file mode 100644
index 0000000..d4c0def
--- /dev/null
+++ b/src/main/kotlin/Application.kt
@@ -0,0 +1,7 @@
+import controller.WordleController
+import presentation.DefaultInput
+import presentation.DefaultOutput
+
+fun main() {
+    WordleController(DefaultInput, DefaultOutput).start()
+}
diff --git a/src/main/kotlin/controller/WordleController.kt b/src/main/kotlin/controller/WordleController.kt
new file mode 100644
index 0000000..43e25ef
--- /dev/null
+++ b/src/main/kotlin/controller/WordleController.kt
@@ -0,0 +1,32 @@
+package controller
+
+import domain.Game
+import domain.Input
+import domain.MatchResults
+import domain.Output
+import infra.WordsPool
+
+class WordleController(
+    private val input: Input,
+    private val output: Output
+) {
+
+    fun start() {
+        val game = Game(WordsPool())
+        do {
+            var result: MatchResults
+
+            try {
+                result = game.progress(input)
+            } catch (e: IllegalArgumentException) {
+                println(e.message)
+                continue
+            }
+            output.write(result)
+
+            if (result.isCorrect()) {
+                break
+            }
+        } while (!game.checkToRetry())
+    }
+}
diff --git a/src/main/kotlin/domain/Answer.kt b/src/main/kotlin/domain/Answer.kt
new file mode 100644
index 0000000..0fe558b
--- /dev/null
+++ b/src/main/kotlin/domain/Answer.kt
@@ -0,0 +1,75 @@
+package domain
+
+import domain.MatchResult.INCORRECT
+import domain.MatchResult.MISSING
+
+class Answer(val tiles: Tiles) {
+    init {
+        require(tiles.size == REQUIRE_TILE_SIZE) { ERROR_TILE_SIZE_MSG }
+    }
+
+    fun match(other: Tiles): MatchResults {
+        val result: Array<MatchResult> = arrayOf(INCORRECT, INCORRECT, INCORRECT, INCORRECT, INCORRECT)
+        val countOfTile: MutableMap<Tile, Int> = tiles.groupingBy { it }.eachCount().toMutableMap()
+
+        fillGreens(result, other, countOfTile)
+        fillYellows(result, other, countOfTile)
+
+        return MatchResults(result.toList())
+    }
+
+    private fun fillGreens(
+        result: Array<MatchResult>,
+        other: Tiles,
+        countOfTile: MutableMap<Tile, Int>
+    ) {
+        other.mapIndexed { index, tile ->
+            fillGreen(tile, index, result, countOfTile)
+        }
+    }
+    private fun fillYellows(
+        result: Array<MatchResult>,
+        other: Tiles,
+        countOfTile: MutableMap<Tile, Int>
+    ) {
+        other.mapIndexed { index, tile ->
+            fillYellow(tile, index, result, countOfTile)
+        }
+    }
+
+    private fun fillGreen(
+        tile: Tile,
+        index: Int,
+        result: Array<MatchResult>,
+        countOfTile: MutableMap<Tile, Int>
+    ) {
+        if (this.tiles.equals(tile, index)) {
+            result[index] = MatchResult.CORRECT
+
+            countOfTile[tile] = countOfTile[tile]!!.dec()
+        }
+    }
+
+    private fun fillYellow(
+        tile: Tile,
+        index: Int,
+        result: Array<MatchResult>,
+        countOfTile: MutableMap<Tile, Int>
+    ) {
+        val count = countOfTile[tile] ?: EMPTY
+
+        if (result[index] == INCORRECT && count > EMPTY) {
+            result[index] = MISSING
+
+            countOfTile[tile] = count.dec()
+        }
+    }
+
+    companion object {
+        const val ERROR_TILE_SIZE_MSG = "타일은 5개로 구성되어야 합니다."
+        const val REQUIRE_TILE_SIZE = 5
+        const val EMPTY = 0
+
+        fun of(words: String): Answer = Answer(Tiles.of(words))
+    }
+}
diff --git a/src/main/kotlin/domain/Game.kt b/src/main/kotlin/domain/Game.kt
new file mode 100644
index 0000000..23f9a00
--- /dev/null
+++ b/src/main/kotlin/domain/Game.kt
@@ -0,0 +1,26 @@
+package domain
+
+class Game(private val words: Words) {
+    private val answer: Answer = Answer(words.getTodayWords())
+    private var tryCount = 0
+
+    fun progress(input: Input): MatchResults {
+        val tiles = input.read()
+        checkWord(tiles)
+        tryCount++
+        return answer.match(tiles)
+    }
+
+    fun checkToRetry() = MAX_TRY_COUNT == tryCount
+
+    private fun checkWord(tiles: Tiles) {
+        if (!words.exists(tiles)) {
+            throw IllegalArgumentException(NOT_FOUND_WORD)
+        }
+    }
+
+    companion object {
+        private const val MAX_TRY_COUNT = 6
+        private const val NOT_FOUND_WORD = "존재하지 않는 단어입니다"
+    }
+}
diff --git a/src/main/kotlin/domain/Input.kt b/src/main/kotlin/domain/Input.kt
new file mode 100644
index 0000000..8b5c03b
--- /dev/null
+++ b/src/main/kotlin/domain/Input.kt
@@ -0,0 +1,5 @@
+package domain
+
+fun interface Input {
+    fun read(): Tiles
+}
diff --git a/src/main/kotlin/domain/MatchResult.kt b/src/main/kotlin/domain/MatchResult.kt
new file mode 100644
index 0000000..3328fd8
--- /dev/null
+++ b/src/main/kotlin/domain/MatchResult.kt
@@ -0,0 +1,7 @@
+package domain
+
+enum class MatchResult {
+    CORRECT,
+    MISSING,
+    INCORRECT
+}
diff --git a/src/main/kotlin/domain/MatchResults.kt b/src/main/kotlin/domain/MatchResults.kt
new file mode 100644
index 0000000..45d0470
--- /dev/null
+++ b/src/main/kotlin/domain/MatchResults.kt
@@ -0,0 +1,14 @@
+package domain
+
+data class MatchResults(val results: List<MatchResult>) {
+    init {
+        require(results.size == REQUIRE_RESULTS_SIZE) { ERROR_RESULTS_SIZE_MSG }
+    }
+
+    fun isCorrect(): Boolean = results.all { it == MatchResult.CORRECT }
+
+    companion object {
+        const val ERROR_RESULTS_SIZE_MSG = "결과는 5개로 구성되어야 합니다."
+        const val REQUIRE_RESULTS_SIZE = 5
+    }
+}
diff --git a/src/main/kotlin/domain/Output.kt b/src/main/kotlin/domain/Output.kt
new file mode 100644
index 0000000..5a86732
--- /dev/null
+++ b/src/main/kotlin/domain/Output.kt
@@ -0,0 +1,5 @@
+package domain
+
+fun interface Output {
+    fun write(matchResults: MatchResults)
+}
diff --git a/src/main/kotlin/domain/Tile.kt b/src/main/kotlin/domain/Tile.kt
new file mode 100644
index 0000000..4d60863
--- /dev/null
+++ b/src/main/kotlin/domain/Tile.kt
@@ -0,0 +1,13 @@
+package domain
+
+@JvmInline
+value class Tile(val character: Char) {
+    init {
+        require(character in ALLOWED_CHARACTER) { ERROR_ALLOWED_CHARACTER_MSG }
+    }
+
+    companion object {
+        const val ERROR_ALLOWED_CHARACTER_MSG = "문자는 알파벳만 입력이 가능합니다."
+        val ALLOWED_CHARACTER = 'a'..'z'
+    }
+}
diff --git a/src/main/kotlin/domain/Tiles.kt b/src/main/kotlin/domain/Tiles.kt
new file mode 100644
index 0000000..d2a2cbe
--- /dev/null
+++ b/src/main/kotlin/domain/Tiles.kt
@@ -0,0 +1,18 @@
+package domain
+
+data class Tiles(val tiles: List<Tile>) : List<Tile> by tiles {
+    init {
+        require(tiles.size == REQUIRE_TILE_SIZE) { ERROR_TILE_SIZE_MSG }
+    }
+
+    fun equals(tile: Tile, index: Int): Boolean = this.tiles[index] == tile
+
+    fun countOf(tile: Tile): Int = this.tiles.count { it == tile }
+
+    companion object {
+        const val ERROR_TILE_SIZE_MSG = "타일은 5개로 구성되어야 합니다."
+        const val REQUIRE_TILE_SIZE = 5
+
+        fun of(words: String): Tiles = Tiles(words.map { Tile(it) })
+    }
+}
diff --git a/src/main/kotlin/domain/Words.kt b/src/main/kotlin/domain/Words.kt
new file mode 100644
index 0000000..c5a429f
--- /dev/null
+++ b/src/main/kotlin/domain/Words.kt
@@ -0,0 +1,7 @@
+package domain
+
+interface Words {
+    fun exists(tiles: Tiles): Boolean
+
+    fun getTodayWords(): Tiles
+}
diff --git a/src/main/kotlin/infra/WordsPool.kt b/src/main/kotlin/infra/WordsPool.kt
new file mode 100644
index 0000000..df91e33
--- /dev/null
+++ b/src/main/kotlin/infra/WordsPool.kt
@@ -0,0 +1,31 @@
+package infra
+
+import domain.Tiles
+import domain.Words
+import java.io.File
+import java.time.LocalDate
+
+class WordsPool : Words {
+
+    private val today: Tiles
+
+    init {
+        val nowEpochDay = LocalDate.now().toEpochDay()
+        val daysFromStandard = (nowEpochDay - BASE_TIME_EPOCH_DAY).toInt()
+        this.today = WORDS[daysFromStandard % WORDS.size]
+    }
+
+    override fun exists(tiles: Tiles): Boolean {
+        return WORDS.contains(tiles)
+    }
+
+    override fun getTodayWords(): Tiles {
+        return today
+    }
+
+    companion object {
+        private val BASE_TIME_EPOCH_DAY = LocalDate.of(2021, 6, 19).toEpochDay()
+        private val WORDS: List<Tiles> =
+            File(ClassLoader.getSystemResource("words.txt").file).bufferedReader().readLines().map { Tiles.of(it) }
+    }
+}
diff --git a/src/main/kotlin/presentation/DefaultInput.kt b/src/main/kotlin/presentation/DefaultInput.kt
new file mode 100644
index 0000000..ffa63ca
--- /dev/null
+++ b/src/main/kotlin/presentation/DefaultInput.kt
@@ -0,0 +1,14 @@
+package presentation
+
+import domain.Input
+import domain.Tiles
+
+object DefaultInput : Input {
+    private const val INPUT_MESSAGE = "정답을 입력해 주세요."
+
+    override fun read(): Tiles {
+        println(INPUT_MESSAGE)
+        val text = readln()
+        return Tiles.of(text)
+    }
+}
diff --git a/src/main/kotlin/presentation/DefaultOutput.kt b/src/main/kotlin/presentation/DefaultOutput.kt
new file mode 100644
index 0000000..44880e1
--- /dev/null
+++ b/src/main/kotlin/presentation/DefaultOutput.kt
@@ -0,0 +1,42 @@
+package presentation
+
+import domain.MatchResult
+import domain.MatchResults
+import domain.Output
+
+object DefaultOutput : Output {
+    private const val BLANK = ""
+    private const val MAX_TRY_COUNT = 6
+
+    private val allResults: MutableList<MatchResults> = mutableListOf()
+
+    override fun write(matchResults: MatchResults) {
+        allResults.add(matchResults)
+
+        if (matchResults.isCorrect()) {
+            println("${allResults.size}/$MAX_TRY_COUNT")
+        }
+
+        printAll()
+    }
+
+    private fun printAll() {
+        allResults.forEach {
+            printLine(it)
+        }
+    }
+
+    private fun printLine(matchResults: MatchResults) {
+        println(
+            matchResults.results.joinToString(BLANK) {
+                blockOf(it)
+            }
+        )
+    }
+
+    private fun blockOf(matchResult: MatchResult): String = when (matchResult) {
+        MatchResult.CORRECT -> "\uD83D\uDFE9"
+        MatchResult.MISSING -> "\uD83D\uDFE8"
+        else -> "⬜"
+    }
+}
diff --git a/src/test/kotlin/domain/AnswerTest.kt b/src/test/kotlin/domain/AnswerTest.kt
new file mode 100644
index 0000000..237d30e
--- /dev/null
+++ b/src/test/kotlin/domain/AnswerTest.kt
@@ -0,0 +1,82 @@
+package domain
+
+import domain.MatchResult.CORRECT
+import domain.MatchResult.INCORRECT
+import domain.MatchResult.MISSING
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.ShouldSpec
+import io.kotest.data.forAll
+import io.kotest.data.headers
+import io.kotest.data.row
+import io.kotest.data.table
+import io.kotest.matchers.collections.shouldContain
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.shouldBe
+
+internal class AnswerTest : ShouldSpec({
+    context("Answer는") {
+        val answer = Answer.of("hello")
+
+        context("5개 Tile 로") {
+            val tiles = Tiles.of("hello")
+            should("구성되어 있다") {
+                answer.tiles shouldBe tiles
+            }
+        }
+
+        context("5개가 아닌 Tile 은") {
+            should("실패한다") {
+                forAll(
+                    table(
+                        headers("word"),
+                        row(""),
+                        row("h"),
+                        row("hell"),
+                        row("hellow"),
+                    )
+                ) { word ->
+                    shouldThrow<IllegalArgumentException> { Answer.of(word) }
+                }
+            }
+        }
+
+        context("답안과 비교하여") {
+
+            should("같은 위치에 있으면 CORRECT이다") {
+                val tiles = Tiles.of("hello")
+                val matches = answer.match(tiles)
+                matches.results shouldContainExactly listOf(CORRECT, CORRECT, CORRECT, CORRECT, CORRECT)
+            }
+
+            should("다른 위치에 있으면 MISSING이다") {
+                val tiles = Tiles.of("olehl")
+                val matches = answer.match(tiles)
+                matches.results shouldContain MISSING
+            }
+
+            should("없을 경우 INCORRECT이다") {
+                val tiles = Tiles.of("zzzzz")
+                val matches = answer.match(tiles)
+                matches.results shouldContain INCORRECT
+            }
+
+            should("맞는 부분을 CORRECT로 변경하고 나머지 존재하는 부분을 MISSING으로 변경된다 ") {
+                val tiles = Tiles.of("olleh")
+                val matches = answer.match(tiles)
+                matches.results shouldContainExactly listOf(MISSING, MISSING, CORRECT, MISSING, MISSING)
+            }
+
+            should("정답이 뒤에 있으면 정답부터 CORRECT으로 변경된다") {
+                val tiles = Tiles.of("lllll")
+                val matches = answer.match(tiles)
+                matches.results shouldContainExactly listOf(INCORRECT, INCORRECT, CORRECT, CORRECT, INCORRECT)
+            }
+
+            should("답안에 있는 타일이 정답 개수보다 많으면 겹치는 부분을 제외한 부분이 INCORRECT으로 변경된다") {
+                val tiles = Tiles.of("llool")
+                val matches = answer.match(tiles)
+                matches.results shouldContainExactly listOf(MISSING, MISSING, MISSING, INCORRECT, INCORRECT)
+            }
+        }
+    }
+})
diff --git a/src/test/kotlin/domain/GameTest.kt b/src/test/kotlin/domain/GameTest.kt
new file mode 100644
index 0000000..bb57242
--- /dev/null
+++ b/src/test/kotlin/domain/GameTest.kt
@@ -0,0 +1,76 @@
+package domain
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.BehaviorSpec
+import io.kotest.inspectors.forAll
+import io.kotest.matchers.shouldBe
+
+class GameTest : BehaviorSpec({
+    val answer = Tiles.of("hello")
+
+    Given("하나의 답안에") {
+        val input = TestInput("hello")
+        val repository = TestWordsRepository(answer, setOf(Tiles(answer)))
+        val game = Game(repository)
+
+        When("정답이 있을 경우") {
+            val result = game.progress(input)
+
+            then("게임이 종료 된다") {
+                result.isCorrect() shouldBe true
+            }
+        }
+    }
+
+    Given("답안을 7번 이상") {
+        val input = listOf("abcde", "abcde", "abcde", "abcde", "abcde", "abcde", "abcde").map { TestInput(it) }
+        val repository = TestWordsRepository(answer, setOf(Tiles(answer), Tiles.of("abcde")))
+        val game = Game(repository)
+
+        When("적으면") {
+            input.forEach {
+                game.progress(it)
+            }
+
+            Then("더이상 시도할 수 없다") {
+                game.checkToRetry() shouldBe false
+            }
+        }
+    }
+
+    Given("존재하지 않는 단어는") {
+        val input = listOf("abcde", "abcde", "abcde", "abcde", "abcde", "abcde", "abcde").map { TestInput(it) }
+        val repository = TestWordsRepository(answer, setOf(Tiles(answer)))
+        val game = Game(repository)
+
+        Then("예외를 발생시킨다") {
+            input.forAll {
+                shouldThrow<IllegalArgumentException> {
+                    game.progress(it)
+                }
+            }
+        }
+    }
+})
+
+class TestInput(private val word: String) : Input {
+    override fun read(): Tiles {
+        return Tiles.of(word)
+    }
+}
+
+class TestWordsRepository(val answer: Tiles, val words: Set<Tiles>) : Words {
+    var tilesStack = mutableListOf<Tiles>()
+    var calledTodayWords = false
+
+    override fun exists(tiles: Tiles): Boolean {
+        tilesStack.add(tiles)
+
+        return words.contains(tiles)
+    }
+
+    override fun getTodayWords(): Tiles {
+        calledTodayWords = true
+        return answer
+    }
+}
diff --git a/src/test/kotlin/domain/MatchResultsTest.kt b/src/test/kotlin/domain/MatchResultsTest.kt
new file mode 100644
index 0000000..11e1dae
--- /dev/null
+++ b/src/test/kotlin/domain/MatchResultsTest.kt
@@ -0,0 +1,52 @@
+package domain
+
+import domain.MatchResult.CORRECT
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatIllegalArgumentException
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.EnumSource
+import org.junit.jupiter.params.provider.ValueSource
+
+internal class MatchResultsTest {
+    @Test
+    fun `5개의 결과로 이뤄진다`() {
+        // given
+        val matchResult = listOf(CORRECT, CORRECT, CORRECT, CORRECT, CORRECT)
+        val result = MatchResults(matchResult)
+
+        // then
+        assertThat(result.results).containsExactlyElementsOf(matchResult)
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = [0, 1, 2, 3, 4, 6, 7, 8])
+    fun `5개의 결과가 아니면 실패한다`(size: Int) {
+        // given
+        val matchResult = (0 until size).map { CORRECT }
+
+        // then
+        assertThatIllegalArgumentException().isThrownBy {
+            MatchResults(matchResult)
+        }.withMessage(MatchResults.ERROR_RESULTS_SIZE_MSG)
+    }
+
+    @Test
+    fun `모든 MatchResult가 성공이면 MatchResults도 성공이다`() {
+        // given
+        val result = MatchResults(listOf(CORRECT, CORRECT, CORRECT, CORRECT, CORRECT))
+
+        // then
+        assertThat(result.isCorrect()).isTrue
+    }
+
+    @ParameterizedTest
+    @EnumSource(value = MatchResult::class, names = ["MISSING", "INCORRECT"])
+    fun `모든 MatchResult가 성공이 아니면 MatchResults는 성공이 아니다`(result: MatchResult) {
+        // given
+        val result = MatchResults(listOf(CORRECT, CORRECT, CORRECT, CORRECT, result))
+
+        // then
+        assertThat(result.isCorrect()).isFalse
+    }
+}
diff --git a/src/test/kotlin/domain/TileTest.kt b/src/test/kotlin/domain/TileTest.kt
new file mode 100644
index 0000000..115a536
--- /dev/null
+++ b/src/test/kotlin/domain/TileTest.kt
@@ -0,0 +1,46 @@
+package domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatIllegalArgumentException
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+
+internal class TileTest {
+    @Test
+    fun `타일은 하나의 문자를 가지고 있다`() {
+        // given
+        val tile = Tile('a')
+
+        // then
+        assertThat(tile.character).isEqualTo('a')
+    }
+
+    @ParameterizedTest
+    @ValueSource(chars = [' ', '0', '1', '5', '9', 'ㄱ', '⬜'])
+    fun `타일은 알파벳만 입력이 가능하다`(character: Char) {
+        assertThatIllegalArgumentException()
+            .isThrownBy { Tile(character) }
+            .withMessage(Tile.ERROR_ALLOWED_CHARACTER_MSG)
+    }
+
+    @Test
+    fun `두개의 Tile이 서로 일치하면 참을 반환한다`() {
+        // given
+        val tile = Tile('a')
+        val anotherTile = Tile('a')
+
+        // then
+        assertThat(tile).isEqualTo(anotherTile)
+    }
+
+    @Test
+    fun `두개의 Tile이 서로 다르면 거짓을 반환한다`() {
+        // given
+        val tile = Tile('a')
+        val anotherTile = Tile('b')
+
+        // then
+        assertThat(tile).isNotEqualTo(anotherTile)
+    }
+}
diff --git a/src/test/kotlin/domain/TilesTest.kt b/src/test/kotlin/domain/TilesTest.kt
new file mode 100644
index 0000000..4dffc79
--- /dev/null
+++ b/src/test/kotlin/domain/TilesTest.kt
@@ -0,0 +1,80 @@
+package domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatIllegalArgumentException
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+import org.junit.jupiter.params.provider.ValueSource
+
+internal class TilesTest {
+    @Test
+    fun `Tiles는 5개의 Tile로 구성이 되어있다`() {
+        // given
+        val elements = listOf(Tile('a'), Tile('b'), Tile('c'), Tile('d'), Tile('e'))
+
+        // when
+        val tiles = Tiles(elements)
+
+        // then
+        assertThat(tiles.tiles).containsExactlyElementsOf(elements)
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = [0, 1, 2, 3, 4, 6, 10])
+    fun `Tiles는 5개의 Tile로 구성이 안되면 실패한다`(size: Int) {
+        // given
+        val elements: List<Tile> = (0 until size).map { Tile('a') }
+
+        // then
+        assertThatIllegalArgumentException()
+            .isThrownBy { Tiles(elements) }
+            .withMessage(Tiles.ERROR_TILE_SIZE_MSG)
+    }
+
+    @Test
+    fun `Tiles는 문자열 5글자로 구성 할 수 있다`() {
+        // given
+        val tiles = Tiles.of("hello")
+
+        // then
+        assertThat(tiles.tiles)
+            .containsExactly(Tile('h'), Tile('e'), Tile('l'), Tile('l'), Tile('o'))
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = ["", "h", "hell", "hellow"])
+    fun `Tiles는 문자열 5글자로 구성이 안되면 실패한다`(words: String) {
+        // then
+        assertThatIllegalArgumentException()
+            .isThrownBy { Tiles.of(words) }
+            .withMessage(Tiles.ERROR_TILE_SIZE_MSG)
+    }
+
+    @ParameterizedTest
+    @CsvSource(
+        value = [
+            "h,0,true", "e,1,true", "l,2,true", "l,3,true", "o,4,true", // 성공케이스
+            "a,0,false", "b,1,false", "c,2,false", "d,3,false", "e,4,false" // 실패케이스
+        ]
+    )
+    fun `Tiles는 위치와 Tile을 받아서 해당 위치에 같은 타일이 있는지 확인할 수 있다`(tile: Char, index: Int, result: Boolean) {
+        // given
+        val tile = Tile(tile)
+        val tiles = Tiles.of("hello")
+
+        // then
+        assertThat(tiles.equals(tile, index)).isEqualTo(result)
+    }
+
+    @ParameterizedTest
+    @CsvSource(value = ["h,1", "e,1", "l,2", "o,1", "z,0"])
+    fun `Tiles에 Tile이 몇개 있는지 확인할 수 있다`(tile: Char, count: Int) {
+        // given
+        val tiles = Tiles.of("hello")
+        val tile = Tile(tile)
+
+        // then
+        assertThat(tiles.countOf(tile)).isEqualTo(count)
+    }
+}