diff --git a/.gitignore b/.gitignore
index 6c018781..687f03d8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,3 +30,147 @@ out/
 
 ### VS Code ###
 .vscode/
+
+
+# Created by https://www.toptal.com/developers/gitignore/api/macos,intellij
+# Edit at https://www.toptal.com/developers/gitignore?templates=macos,intellij
+
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Intellij Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+# https://plugins.jetbrains.com/plugin/7973-sonarlint
+.idea/**/sonarlint/
+
+# SonarQube Plugin
+# https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin
+.idea/**/sonarIssues.xml
+
+# Markdown Navigator plugin
+# https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator-enh.xml
+.idea/**/markdown-navigator/
+
+# Cache file creation bug
+# See https://youtrack.jetbrains.com/issue/JBR-2257
+.idea/$CACHE_FILE$
+
+# CodeStream plugin
+# https://plugins.jetbrains.com/plugin/12206-codestream
+.idea/codestream.xml
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# End of https://www.toptal.com/developers/gitignore/api/macos,intellij
\ No newline at end of file
diff --git a/README.md b/README.md
index 03ba7ed3..f45b8b57 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,119 @@
-# java-blackjack
\ No newline at end of file
+# 📌 연료 주입
+
+##  기능 요구 사항
+우리 회사는 렌터카를 운영하고 있다.
+현재 보유하고 있는 차량은 Sonata 2대, Avante 1대, K5 2대로 총 5대의 차량을 보유하고 있다.
+고객이 인터넷으로부터 예약할 때 여행할 목적지의 대략적인 이동거리를 입력 받는다.
+이 이동거리를 활용해 차량 별로 필요한 연료를 주입한다. 차량 별로 주입해야 할 연료량을 확인할 수 있는 보고서를 생성해야 한다.
+
+각 차량별 연비는 다음과 같다.
+
+* Sonata : 10km/리터
+* Avante : 15km/리터
+* K5 : 13km/리터
+
+
+## 구현 사항
+- [x] 입력 (e.g. carName1:distance, carName2:distance)
+    - [x] 문자 사이에 불필요한 공백을 제거한다.
+
+- [x] 파서 - Parser
+    - [x] 자동차는 `,` 로 구분한다.
+    - [x] 자동차의 이름과 속력은 `:` 로 구분한다.
+    - [x] 검증
+        - [x] 빈 값이 들어올 수 없다.
+        - [x] 이름이나 거리에 빈 값이 들어올 수 없다.
+        - [x] 입력 형식에 맞는지 확인한다. 
+
+- [x] 렌터카 회사 - RentCompany
+    - [x] 자동차 객체를 받아 예약을 승인한다. - acceptReservation(List<RentInfo> rentInfos)
+        - [x] 보유한 렌터카의 수를 넘지 않는다. - validateOverMinTripDistance
+    - [x] 차량 별로 주입해야 할 연료량을 확인할 수 있는 보고서를 생성한다. - createReport
+
+- [x] 자동차 - abstract
+    - [x] 주입해야 할 연료량을 구한다. - getChargeQuantity
+
+- [x] 렌트카 -RentCar
+  - [x] 여행 거리와 타입을 받아 Car 객체 생성.
+  - [x] 검증
+    - [x] 자동차 이름 확인(대소문자 구분 X)
+    - [x] 거리는 1 이상이어야 한다.
+
+- [x] 출력
+    - [x] 생성한 보고서 출력.
+
+
+# 📌 블랙잭
+
+## 기능 요구 사항
+블랙잭 게임을 변형한 프로그램을 구현한다. 블랙잭 게임은 `딜러`와 `플레이어` 중 카드의 합이 21 또는 21에 가장 가까운 숫자를 가지는 쪽이 이기는 게임이다.
+
+카드의 숫자 계산은 카드 숫자를 기본으로 하며, 예외로 `Ace는 1 또는 11`로 계산한다.
+- King, Queen, Jack은 각각 10으로 계산한다.
+- 게임을 시작하면 플레이어는 두 장의 카드를 지급 받는다.
+- 두 장의 카드 숫자를 합쳐 21을 초과하지 않으면서 21에 가깝게 만들면 이긴다. 21을 넘지 않을 경우 원한다면 얼마든지 카드를 계속 뽑을 수 있다.
+- 딜러는 처음에 받은 2장의 합계가 16이하이면 반드시 1장의 카드를 추가로 받아야 하고, 17점 이상이면 추가로 받을 수 없다.
+- 게임을 완료한 후 각 플레이어별로 승패를 출력한다.
+  - 딜러와 플레이어의 카드 합이 같을 경우, 딜러가 승리한다.
+  - 딜러와 플레이어가 모두 21을 넘었을 때, 딜러가 승리한다. 
+
+- 카드 : 스페이드, 클로버, 하트, 다이아 1~10, JQK
+
+## 구현 사항.
+
+- [x] InputView
+  - [x] 플레이어의 이름을 받는다. (`,`로 구분)
+  - [x] 카드를 받을 지에 대한 여부 입력 (`y`, `n`으로 구분)
+    - [x] 'y' 와 'n'이 아닐 경우 exception이 발생한다.
+
+- [x] Parser
+  - [x] 플레이어 이름이 비어있는지 확인한다.
+
+- [x] Deck
+  - [x] 카드 분배
+
+- [x] Cards
+  - [x] Cards(list<Card>: pattern, rank)
+  - [x] 카드 뽑기 - draw
+    - [x] 빈 덱이라면 예외 발생
+  - [x] 카드 제거 - Cards remove(Card card)
+
+- [x] Card
+  - [x] ACE 인지 확인.
+  - [x] 이름(patter + rank)
+
+- [x] Hands
+  - [x] 두 장의 카드로 초기화
+  - [x] 카드 관리
+  - [x] 현재 점수 관리
+  - [x] ACE의 값을 결정한다. 
+
+- [x] Score
+  - [x] Card의 합
+  - [x] 기존 합에 한장의 Card의 값을 더한 값을 반환한다.
+
+- [x] Judge
+  - [x] 승패 구하기
+  - [x] 딜러와 플레이어의 카드 합이 같을 경우, 딜러가 승리한다.   
+  - [x] 딜러와 플레이어가 모두 21을 넘었을 때, 딜러가 승리한다.
+
+- [x] abstract Participant (딜러, 플레이어)
+  - [x] 이름을 가진다. 
+  - [x] 자신의 패를 가진다. 
+  - [x] 카드패의 합산을 구한다. (구현)
+  - [x] 카드를 더 받을 수 있는지.
+
+- [x] Player extends Participant
+  - [x] 플레이어 이름을 반환한다. (Override)
+  - [x] 카드를 더 받을 수 있는지. (Override) -> 카드의 합이 21을 초과하면 턴을 종료한다.
+
+- [x] Dealer extends Participant
+  - [x] '딜러' 를 반환한다. (Override)
+  - [x] 카드를 더 받을 수 있는지. (Override) -> 카드의 합이 16을 초과하면 턴을 종료한다.
+  
+- [x] OutputView
+  - [x] 참가자 패
+  - [x] 참가자 카드 분배
+  - [x] 참가자 최종 결과
+  - [x] 참가자 최종 승패
+  - [x] 딜러는 16이하라 한장의 카드를 더 받았습니다.
diff --git a/src/main/java/blackjack/BlackJackApplication.java b/src/main/java/blackjack/BlackJackApplication.java
new file mode 100644
index 00000000..5a313309
--- /dev/null
+++ b/src/main/java/blackjack/BlackJackApplication.java
@@ -0,0 +1,63 @@
+package blackjack;
+
+import blackjack.domain.judge.Judge;
+import blackjack.domain.card.Deck;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Participant;
+import blackjack.domain.participant.Player;
+import blackjack.util.Parser;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class BlackJackApplication {
+
+    public static void main(String[] args) {
+        final Deck deck = new Deck();
+
+        final List<String> playerNames = Parser.parse(InputView.inputPlayerNames());
+        final Participant dealer = new Dealer(deck.dealCards());
+        final List<Participant> players = playerNames.stream()
+            .map(name -> new Player(name, deck.dealCards()))
+            .collect(Collectors.toList());
+
+        OutputView.printStartStatus(combine(dealer, players));
+
+        drawCardsIfWant(deck, players);
+        drawCardIfCan(deck, dealer);
+
+        final Judge judge = new Judge();
+        OutputView.printGameResult(combine(dealer, players), judge.getWinOrLose(dealer, players));
+    }
+
+    private static void drawCardsIfWant(final Deck deck, final List<Participant> players) {
+        players.forEach(player -> additionalDraw(deck, player));
+    }
+
+    private static void additionalDraw(final Deck deck, final Participant player) {
+        while (player.canDraw() && isAgree(player)) {
+            player.addCard(deck.draw());
+            OutputView.printParticipantsStatus(Collections.singletonList(player));
+        }
+    }
+
+    private static boolean isAgree(final Participant player) {
+        return InputView.inputDrawFlag(player.getName()).equalsIgnoreCase("y");
+    }
+
+    private static void drawCardIfCan(final Deck deck, final Participant dealer) {
+        if (dealer.canDraw()) {
+            dealer.addCard(deck.draw());
+            OutputView.printDealerDrawMessage();
+        }
+    }
+
+    private static List<Participant> combine(final Participant dealer, final List<Participant> participants) {
+        return Collections.unmodifiableList(
+            Stream.concat(Stream.of(dealer), participants.stream())
+                .collect(Collectors.toList()));
+    }
+}
diff --git a/src/main/java/blackjack/domain/card/Card.java b/src/main/java/blackjack/domain/card/Card.java
new file mode 100644
index 00000000..bd547642
--- /dev/null
+++ b/src/main/java/blackjack/domain/card/Card.java
@@ -0,0 +1,43 @@
+package blackjack.domain.card;
+
+import java.util.Objects;
+
+public class Card {
+
+    private final Pattern pattern;
+    private final Rank rank;
+
+    public Card(final Pattern pattern, final Rank rank) {
+        this.pattern = pattern;
+        this.rank = rank;
+    }
+
+    public boolean isAce() {
+        return rank == Rank.ACE;
+    }
+
+    public String getName() {
+        return rank.getName() + pattern.getName();
+    }
+
+    public int getRank() {
+        return rank.getValue();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Card card = (Card) o;
+        return pattern == card.pattern && rank == card.rank;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(pattern, rank);
+    }
+}
diff --git a/src/main/java/blackjack/domain/card/Cards.java b/src/main/java/blackjack/domain/card/Cards.java
new file mode 100644
index 00000000..c5097997
--- /dev/null
+++ b/src/main/java/blackjack/domain/card/Cards.java
@@ -0,0 +1,45 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Cards {
+
+    private static final String EMPTY_DECK_EXCEPTION_MESSAGE = "[ERROR] 덱에 남은 카드가 없습니다.";
+    private static final int SELECTED_CARD = 0;
+
+    private final List<Card> cards;
+
+    public Cards() {
+        this(Arrays.stream(Pattern.values())
+            .flatMap(pattern ->
+                Arrays.stream(Rank.values())
+                    .map(rank -> new Card(pattern, rank))
+                    .collect(Collectors.toList()).stream())
+            .collect(Collectors.toList()));
+    }
+
+    private Cards(final List<Card> cards) {
+        this.cards = new ArrayList<>(cards);
+    }
+
+    public Card draw() {
+        checkDeckIsEmpty();
+        Collections.shuffle(cards);
+        return cards.get(SELECTED_CARD);
+    }
+
+    private void checkDeckIsEmpty() {
+        if (cards.isEmpty()) {
+            throw new IllegalArgumentException(EMPTY_DECK_EXCEPTION_MESSAGE);
+        }
+    }
+
+    public Cards remove(final Card card) {
+        cards.remove(card);
+        return new Cards(cards);
+    }
+}
diff --git a/src/main/java/blackjack/domain/card/Deck.java b/src/main/java/blackjack/domain/card/Deck.java
new file mode 100644
index 00000000..fe96b7f5
--- /dev/null
+++ b/src/main/java/blackjack/domain/card/Deck.java
@@ -0,0 +1,28 @@
+package blackjack.domain.card;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Deck {
+
+    private static final int NUMBER_OF_INIT_HANDS = 2;
+
+    private final Cards cards;
+
+    public Deck() {
+        this.cards = new Cards();
+    }
+
+    public Card draw() {
+        final Card card = cards.draw();
+        cards.remove(card);
+        return card;
+    }
+
+    public List<Card> dealCards() {
+        return IntStream.range(0, NUMBER_OF_INIT_HANDS)
+            .mapToObj(i -> draw())
+            .collect(Collectors.toList());
+    }
+}
diff --git a/src/main/java/blackjack/domain/card/Hands.java b/src/main/java/blackjack/domain/card/Hands.java
new file mode 100644
index 00000000..8dec7f04
--- /dev/null
+++ b/src/main/java/blackjack/domain/card/Hands.java
@@ -0,0 +1,57 @@
+package blackjack.domain.card;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Hands {
+
+    private static final int DECISION_VALUE = 10;
+    private static final int ACE_VALUE_1 = 1;
+    private static final int ACE_VALUE_11 = 11;
+
+    private final List<Card> cards;
+    private Score score;
+
+    public Hands(final List<Card> cards) {
+        this.cards = new ArrayList<>();
+        this.score = new Score();
+
+        initAllField(cards);
+    }
+
+    private void initAllField(final List<Card> cards) {
+        cards.forEach(this::add);
+    }
+
+    public void add(final Card card) {
+        this.cards.add(card);
+        this.score = this.score.sum(getRank(card));
+    }
+
+    private int getRank(final Card card) {
+        if (card.isAce()) {
+            return getAceValue();
+        }
+        return card.getRank();
+    }
+
+    private int getAceValue() {
+        if (this.score.getValue() > DECISION_VALUE) {
+            return ACE_VALUE_1;
+        }
+        return ACE_VALUE_11;
+    }
+
+    public boolean isUnderScore(final int value) {
+        return score.isUnder(value);
+    }
+
+    public int getScore() {
+        return score.getValue();
+    }
+
+    public List<String> getCardNames() {
+        return cards.stream().map(Card::getName).collect(Collectors.toList());
+    }
+}
diff --git a/src/main/java/blackjack/domain/card/Pattern.java b/src/main/java/blackjack/domain/card/Pattern.java
new file mode 100644
index 00000000..563719f0
--- /dev/null
+++ b/src/main/java/blackjack/domain/card/Pattern.java
@@ -0,0 +1,19 @@
+package blackjack.domain.card;
+
+public enum Pattern {
+
+    SPADE("스페이드"),
+    CLUB("클로버"),
+    HEART("하트"),
+    DIAMOND("다이아몬드");
+
+    private final String name;
+
+    Pattern(final String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}
diff --git a/src/main/java/blackjack/domain/card/Rank.java b/src/main/java/blackjack/domain/card/Rank.java
new file mode 100644
index 00000000..f11a8355
--- /dev/null
+++ b/src/main/java/blackjack/domain/card/Rank.java
@@ -0,0 +1,24 @@
+package blackjack.domain.card;
+
+public enum Rank {
+
+    ACE("A", 11), TWO("2", 2), THREE("3", 3), FOUR("4", 4), FIVE("5", 5),
+    SIX("6", 6), SEVEN("7", 7), EIGHT("8", 8), NINE("9", 9), TEN("10", 10),
+    JACK("J", 10), QUEEN("Q", 10), KING("K", 10);
+
+    private final String name;
+    private final int value;
+
+    Rank(final String name, final int value) {
+        this.name = name;
+        this.value = value;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}
diff --git a/src/main/java/blackjack/domain/card/Score.java b/src/main/java/blackjack/domain/card/Score.java
new file mode 100644
index 00000000..b8a7c100
--- /dev/null
+++ b/src/main/java/blackjack/domain/card/Score.java
@@ -0,0 +1,28 @@
+package blackjack.domain.card;
+
+public class Score {
+
+    private static final int INIT_VALUE = 0;
+
+    private final int value;
+
+    public Score() {
+        this(INIT_VALUE);
+    }
+
+    public Score(final int value) {
+        this.value = value;
+    }
+
+    public Score sum(final int value) {
+        return new Score(this.value + value);
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public boolean isUnder(final int value) {
+        return this.value < value;
+    }
+}
diff --git a/src/main/java/blackjack/domain/judge/Judge.java b/src/main/java/blackjack/domain/judge/Judge.java
new file mode 100644
index 00000000..858823a5
--- /dev/null
+++ b/src/main/java/blackjack/domain/judge/Judge.java
@@ -0,0 +1,50 @@
+package blackjack.domain.judge;
+
+import blackjack.domain.participant.Participant;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Judge {
+
+    private static final int LIMIT_SCORE = 21;
+    private static final String PLAYER_WIN = "승";
+    private static final String PLAYER_LOSE = "패";
+    private static final String DEALER_WIN_OR_LOSE_FORMAT = "%d승 %d패";
+
+    public Map<String, String> getWinOrLose(final Participant dealer, final List<Participant> players) {
+        final Map<String, String> winOrLose = new LinkedHashMap<>();
+
+        players.forEach(player -> winOrLose.put(
+            player.getName(),
+            getWinOrLosePerPlayer(player.getScore(), dealer.getScore())));
+
+        final int dealerWinCount = getDealerWinCount(winOrLose);
+        winOrLose.put(dealer.getName(),
+            String.format(DEALER_WIN_OR_LOSE_FORMAT,
+                    dealerWinCount, getDealerLoseCount(winOrLose, dealerWinCount)));
+
+        return winOrLose;
+    }
+
+    private String getWinOrLosePerPlayer(final int playerScore, final int dealerScore) {
+        if (playerScore <= LIMIT_SCORE && dealerScore > LIMIT_SCORE) {
+            return PLAYER_WIN;
+        }
+        if (playerScore > LIMIT_SCORE || playerScore <= dealerScore) {
+            return PLAYER_LOSE;
+        }
+
+        return PLAYER_WIN;
+    }
+
+    private int getDealerWinCount(Map<String, String> result) {
+        return (int) result.values().stream()
+                .filter(v -> v.equals(PLAYER_LOSE))
+                .count();
+    }
+
+    private int getDealerLoseCount(Map<String, String> winOrLose, int dealerWinCount) {
+        return winOrLose.size() - dealerWinCount;
+    }
+}
diff --git a/src/main/java/blackjack/domain/participant/Dealer.java b/src/main/java/blackjack/domain/participant/Dealer.java
new file mode 100644
index 00000000..73df0eca
--- /dev/null
+++ b/src/main/java/blackjack/domain/participant/Dealer.java
@@ -0,0 +1,25 @@
+package blackjack.domain.participant;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Hands;
+import java.util.List;
+
+public class Dealer extends Participant {
+
+    private static final String DEALER = "딜러";
+    private static final int DRAWABLE_SCORE_LIMIT = 17;
+
+    public Dealer(final List<Card> cards) {
+        super(new Hands(cards));
+    }
+
+    @Override
+    public boolean canDraw() {
+        return hands.isUnderScore(DRAWABLE_SCORE_LIMIT);
+    }
+
+    @Override
+    public String getName() {
+        return DEALER;
+    }
+}
diff --git a/src/main/java/blackjack/domain/participant/Participant.java b/src/main/java/blackjack/domain/participant/Participant.java
new file mode 100644
index 00000000..7d6e1d65
--- /dev/null
+++ b/src/main/java/blackjack/domain/participant/Participant.java
@@ -0,0 +1,30 @@
+package blackjack.domain.participant;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Hands;
+import java.util.List;
+
+public abstract class Participant {
+
+    protected final Hands hands;
+
+    Participant(final Hands hands) {
+        this.hands = hands;
+    }
+
+    abstract public boolean canDraw();
+
+    abstract public String getName();
+
+    public int getScore() {
+        return hands.getScore();
+    }
+
+    public List<String> getCardNames() {
+        return hands.getCardNames();
+    }
+
+    public void addCard(final Card card) {
+        hands.add(card);
+    }
+}
diff --git a/src/main/java/blackjack/domain/participant/Player.java b/src/main/java/blackjack/domain/participant/Player.java
new file mode 100644
index 00000000..64416a4f
--- /dev/null
+++ b/src/main/java/blackjack/domain/participant/Player.java
@@ -0,0 +1,27 @@
+package blackjack.domain.participant;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Hands;
+import java.util.List;
+
+public class Player extends Participant {
+
+    private static final int DRAWABLE_SCORE_LIMIT = 21;
+
+    private final String name;
+
+    public Player(final String name, List<Card> cards) {
+        super(new Hands(cards));
+        this.name = name;
+    }
+
+    @Override
+    public boolean canDraw() {
+        return hands.isUnderScore(DRAWABLE_SCORE_LIMIT);
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}
diff --git a/src/main/java/blackjack/util/Parser.java b/src/main/java/blackjack/util/Parser.java
new file mode 100644
index 00000000..ee9af0d5
--- /dev/null
+++ b/src/main/java/blackjack/util/Parser.java
@@ -0,0 +1,30 @@
+package blackjack.util;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BooleanSupplier;
+import java.util.stream.Collectors;
+
+public class Parser {
+
+    private static final String NAME_SPLIT_REGEX = ",";
+    private static final String EMPTY_NAME_EXCEPTION_MESSAGE = "[ERROR] 플레이어의 이름을 빈 값으로 지정할 수 없습니다.";
+
+    public static List<String> parse(final String input) {
+        checkNameIsEmpty(() -> input.endsWith(NAME_SPLIT_REGEX));
+
+        return Arrays.stream(input.split(NAME_SPLIT_REGEX))
+            .map(name -> {
+                final String trimName = name.trim();
+                checkNameIsEmpty(trimName::isEmpty);
+                return trimName;
+            })
+            .collect(Collectors.toList());
+    }
+
+    private static void checkNameIsEmpty(final BooleanSupplier condition) {
+        if (condition.getAsBoolean()) {
+            throw new IllegalArgumentException(EMPTY_NAME_EXCEPTION_MESSAGE);
+        }
+    }
+}
diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java
new file mode 100644
index 00000000..ad8c06f9
--- /dev/null
+++ b/src/main/java/blackjack/view/InputView.java
@@ -0,0 +1,36 @@
+package blackjack.view;
+
+import java.util.Scanner;
+
+public class InputView {
+
+    private static final String PLAYERS_INPUT_MESSAGE = "게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)";
+    private static final String DRAW_FLAG_INPUT_MESSAGE_FORMAT = "%s. 한장의 카드를 더 받으실건가요?(예는 y, 아니오는 n)%n";
+    private static final String DRAW_FLAG_REGEX = "[ynYN]";
+    private static final String INVALID_DRAW_FLAG_EXCEPTION_MESSAGE = "[ERROR] y 또는 n만 입력 가능합니다";
+
+    private InputView() {}
+
+    public static String inputPlayerNames() {
+        System.out.println(PLAYERS_INPUT_MESSAGE);
+        return input();
+    }
+
+    public static String inputDrawFlag(final String name) {
+        System.out.printf(DRAW_FLAG_INPUT_MESSAGE_FORMAT, name);
+        final String input = input();
+        validateDrawFlag(input);
+        return input;
+    }
+
+    private static void validateDrawFlag(final String input) {
+        if (!input.matches(DRAW_FLAG_REGEX)) {
+            throw new IllegalArgumentException(INVALID_DRAW_FLAG_EXCEPTION_MESSAGE);
+        }
+    }
+
+    private static String input() {
+        Scanner scanner = new Scanner(System.in);
+        return scanner.nextLine().trim();
+    }
+}
diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java
new file mode 100644
index 00000000..18ec7990
--- /dev/null
+++ b/src/main/java/blackjack/view/OutputView.java
@@ -0,0 +1,91 @@
+package blackjack.view;
+
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Participant;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class OutputView {
+
+    private static final String DEAL_MESSAGE_FORMAT = "%s에게 카드를 %d장씩 분배하였습니다.%n";
+    private static final int NUMBER_OF_INIT_HANDS = 2;
+    private static final String DELIMITER = ", ";
+    private static final String PARTICIPANT_STATUS_FORMAT = "%s카드: %s%n";
+    private static final int FIRST_CARD = 0;
+    private static final String PARTICIPANT_FINAL_STATUS_FORMAT = "%s카드: %s - 결과: %d%n";
+    private static final String WINNING_OR_LOSE_HEADER_MESSAGE = "## 최종 승패\n";
+    private static final String WINNING_OR_LOSE_FORMAT = "%s: %s%n";
+    private static final String DEALER_DRAW_MESSAGE = "딜러는 16이하라 한장의 카드를 더 받았습니다.\n";
+
+    private OutputView() {}
+
+    public static void printStartStatus(final List<Participant> participants) {
+        printDealResult(participants);
+        printParticipantsStatus(participants);
+    }
+
+    private static void printDealResult(final List<Participant> participants) {
+        System.out.printf(DEAL_MESSAGE_FORMAT, getNames(participants), NUMBER_OF_INIT_HANDS);
+    }
+
+    private static String getNames(final List<Participant> participants) {
+        return participants.stream()
+                .map(Participant::getName)
+                .collect(Collectors.joining(DELIMITER));
+    }
+
+    public static void printParticipantsStatus(final List<Participant> participants) {
+        StringBuilder status = new StringBuilder();
+        participants.forEach(participant ->
+                status.append(String.format(
+                        PARTICIPANT_STATUS_FORMAT, participant.getName(), getStartCardNames(participant))));
+
+        System.out.println(status);
+    }
+
+    private static String getStartCardNames(final Participant participant) {
+        if (participant instanceof Dealer) {
+            return getOneCard(participant);
+        }
+        return getCardNames(participant);
+    }
+
+    private static String getOneCard(Participant participant) {
+        return participant.getCardNames().get(FIRST_CARD);
+    }
+
+    private static String getCardNames(final Participant participant) {
+        return participant.getCardNames().stream()
+                .collect(Collectors.joining(DELIMITER));
+    }
+
+    public static void printGameResult(List<Participant> participants, Map<String, String> result) {
+        printFinalStatus(participants);
+        printWinOrLose(result);
+    }
+
+    private static void printFinalStatus(List<Participant> participants) {
+        StringBuilder status = new StringBuilder();
+        participants.forEach(participant ->
+                status.append(String.format(
+                        PARTICIPANT_FINAL_STATUS_FORMAT, participant.getName(), getCardNames(participant),
+                        participant.getScore())));
+
+        System.out.println(status);
+    }
+
+    private static void printWinOrLose(Map<String, String> results) {
+        StringBuilder winOrLose = new StringBuilder(WINNING_OR_LOSE_HEADER_MESSAGE);
+
+        results.forEach((name, result) ->
+                winOrLose.append(String.format(
+                        WINNING_OR_LOSE_FORMAT, name, result)));
+
+        System.out.println(winOrLose);
+    }
+
+    public static void printDealerDrawMessage() {
+        System.out.println(DEALER_DRAW_MESSAGE);
+    }
+}
diff --git a/src/main/java/empty.txt b/src/main/java/empty.txt
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/main/java/oilinjection/OilInjectionApplication.java b/src/main/java/oilinjection/OilInjectionApplication.java
new file mode 100644
index 00000000..ed5d9989
--- /dev/null
+++ b/src/main/java/oilinjection/OilInjectionApplication.java
@@ -0,0 +1,19 @@
+package oilinjection;
+
+import java.util.List;
+import oilinjection.domain.RentCompany;
+import oilinjection.domain.vo.RentInfo;
+import oilinjection.util.Parser;
+import oilinjection.view.InputView;
+import oilinjection.view.ResultView;
+
+public class OilInjectionApplication {
+
+    public static void main(String[] args) {
+        final List<RentInfo> rentInfos = Parser.parse(InputView.inputReservationInfo());
+
+        final RentCompany rentCompany = new RentCompany();
+        rentCompany.acceptReservation(rentInfos);
+        ResultView.print(rentCompany.createReport());
+    }
+}
diff --git a/src/main/java/oilinjection/domain/RentCar.java b/src/main/java/oilinjection/domain/RentCar.java
new file mode 100644
index 00000000..7d491c11
--- /dev/null
+++ b/src/main/java/oilinjection/domain/RentCar.java
@@ -0,0 +1,52 @@
+package oilinjection.domain;
+
+import java.util.Arrays;
+import java.util.function.Function;
+import oilinjection.domain.car.Avante;
+import oilinjection.domain.car.Car;
+import oilinjection.domain.car.K5;
+import oilinjection.domain.car.Sonata;
+
+public enum RentCar {
+    AVANTE("AVANTE", 1, Avante::new),
+    SONATA("SONATA", 2, Sonata::new),
+    K5("K5", 2, K5::new);
+
+    private static final double MIN_TRIP_DISTANCE = 1D;
+    private static final String UNDER_MIN_TRIP_DISTANCE_EXCEPTION_MESSAGE = "[ERROR] 해당하는 차종이 없습니다.";
+    private static final String NOT_FOUND_NAME_EXCEPTION_MESSAGE = "[ERROR] 해당하는 차종이 없습니다.";
+
+    private final String type;
+    private final int quantity;
+    private final Function<Double, Car> createCar;
+
+    RentCar(final String type, final int quantity, final Function<Double, Car> createCar) {
+        this.type = type;
+        this.quantity = quantity;
+        this.createCar = createCar;
+    }
+
+    public static Car rent(final String type, final double tripDistance) {
+        validateOverMinTripDistance(tripDistance);
+
+        return Arrays.stream(values())
+            .filter(car -> car.type.equals(type.toUpperCase()))
+            .findAny()
+            .orElseThrow(() -> new IllegalArgumentException(NOT_FOUND_NAME_EXCEPTION_MESSAGE))
+            .createCar(tripDistance);
+    }
+
+    private static void validateOverMinTripDistance(final double tripDistance) {
+        if (tripDistance < MIN_TRIP_DISTANCE) {
+            throw new IllegalArgumentException(UNDER_MIN_TRIP_DISTANCE_EXCEPTION_MESSAGE);
+        }
+    }
+
+    private Car createCar(final double tripDistance) {
+        return this.createCar.apply(tripDistance);
+    }
+
+    public boolean isImpossibleReservation(final int count) {
+        return count > this.quantity;
+    }
+}
diff --git a/src/main/java/oilinjection/domain/RentCompany.java b/src/main/java/oilinjection/domain/RentCompany.java
new file mode 100644
index 00000000..2b5b34b0
--- /dev/null
+++ b/src/main/java/oilinjection/domain/RentCompany.java
@@ -0,0 +1,59 @@
+package oilinjection.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import oilinjection.domain.car.Car;
+import oilinjection.domain.vo.RentInfo;
+
+public class RentCompany {
+
+    private static final String QUANTITY_OVER_EXCEPTION_MESSAGE_FORMAT = "[ERROR] %s의 예약 가능한 차량이 없습니다.";
+    private static final String REPORT_FORMAT = "%s : %.0f리터%n";
+
+    private final List<Car> rents;
+
+    public RentCompany() {
+        this.rents = new ArrayList<>();
+    }
+
+    public void acceptReservation(final List<RentInfo> rentInfos) {
+        validateIsPossibleReservation(rentInfos);
+
+        final List<Car> rentCars = rentInfos.stream()
+            .map(this::rent)
+            .collect(Collectors.toList());
+
+        rents.addAll(Collections.unmodifiableList(rentCars));
+    }
+
+    private Car rent(RentInfo rentInfo) {
+        return RentCar.rent(rentInfo.getType(), rentInfo.getTripDistance());
+    }
+
+    private void validateIsPossibleReservation(final List<RentInfo> rentInfos) {
+        rentInfos.stream()
+            .collect(Collectors.groupingBy(RentInfo::getType, Collectors.summingInt(x -> 1)))
+            .forEach(this::validatePerCarType);
+    }
+
+    private void validatePerCarType(final String type, final int count) {
+        if (findRentCar(type).isImpossibleReservation(count)) {
+            throw new IllegalArgumentException(
+                String.format(QUANTITY_OVER_EXCEPTION_MESSAGE_FORMAT, type));
+        }
+    }
+
+    private RentCar findRentCar(final String type) {
+        return RentCar.valueOf(type.toUpperCase());
+    }
+
+    public String createReport() {
+        StringBuilder report = new StringBuilder();
+        rents.forEach(car -> report.append(
+            String.format(REPORT_FORMAT, car.getType(), car.getChargeQuantity())));
+
+        return report.toString();
+    }
+}
diff --git a/src/main/java/oilinjection/domain/car/Avante.java b/src/main/java/oilinjection/domain/car/Avante.java
new file mode 100644
index 00000000..c812ef46
--- /dev/null
+++ b/src/main/java/oilinjection/domain/car/Avante.java
@@ -0,0 +1,21 @@
+package oilinjection.domain.car;
+
+public class Avante extends Car {
+
+    private static final String CAR_TYPE = "Avante";
+    private static final double AVANTE_DISTANCE_PER_LITER = 15D;
+
+    public Avante(final double tripDistance) {
+        super(tripDistance);
+    }
+
+    @Override
+    double getDistancePerLiter() {
+        return AVANTE_DISTANCE_PER_LITER;
+    }
+
+    @Override
+    public String getType() {
+        return CAR_TYPE;
+    }
+}
diff --git a/src/main/java/oilinjection/domain/car/Car.java b/src/main/java/oilinjection/domain/car/Car.java
new file mode 100644
index 00000000..a23e5baa
--- /dev/null
+++ b/src/main/java/oilinjection/domain/car/Car.java
@@ -0,0 +1,41 @@
+package oilinjection.domain.car;
+
+import java.util.Objects;
+
+public abstract class Car {
+
+    final double tripDistance;
+
+    Car(final double tripDistance) {
+        this.tripDistance = tripDistance;
+    }
+
+    abstract double getDistancePerLiter();
+
+    public abstract String getType();
+
+    double getTripDistance() {
+        return this.tripDistance;
+    }
+
+    public double getChargeQuantity() {
+        return Math.ceil(getTripDistance() / getDistancePerLiter());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Car car = (Car) o;
+        return Double.compare(car.tripDistance, tripDistance) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(tripDistance);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/oilinjection/domain/car/K5.java b/src/main/java/oilinjection/domain/car/K5.java
new file mode 100644
index 00000000..1e0ab90f
--- /dev/null
+++ b/src/main/java/oilinjection/domain/car/K5.java
@@ -0,0 +1,21 @@
+package oilinjection.domain.car;
+
+public class K5 extends Car {
+
+    private static final String CAR_TYPE = "K5";
+    private static final double K5_DISTANCE_PER_LITER = 13D;
+
+    public K5(final double tripDistance) {
+        super(tripDistance);
+    }
+
+    @Override
+    double getDistancePerLiter() {
+        return K5_DISTANCE_PER_LITER;
+    }
+
+    @Override
+    public String getType() {
+        return CAR_TYPE;
+    }
+}
diff --git a/src/main/java/oilinjection/domain/car/Sonata.java b/src/main/java/oilinjection/domain/car/Sonata.java
new file mode 100644
index 00000000..e08a411e
--- /dev/null
+++ b/src/main/java/oilinjection/domain/car/Sonata.java
@@ -0,0 +1,21 @@
+package oilinjection.domain.car;
+
+public class Sonata extends Car {
+
+    private static final String CAR_TYPE = "Sonata";
+    private static final double SONATA_DISTANCE_PER_LITER = 10D;
+
+    public Sonata(final double tripDistance) {
+        super(tripDistance);
+    }
+
+    @Override
+    double getDistancePerLiter() {
+        return SONATA_DISTANCE_PER_LITER;
+    }
+
+    @Override
+    public String getType() {
+        return CAR_TYPE;
+    }
+}
diff --git a/src/main/java/oilinjection/domain/vo/RentInfo.java b/src/main/java/oilinjection/domain/vo/RentInfo.java
new file mode 100644
index 00000000..6aa69431
--- /dev/null
+++ b/src/main/java/oilinjection/domain/vo/RentInfo.java
@@ -0,0 +1,40 @@
+package oilinjection.domain.vo;
+
+import java.util.Objects;
+
+public class RentInfo {
+
+    private final String type;
+    private final double tripDistance;
+
+    public RentInfo(final String type, final double tripDistance) {
+        this.type = type;
+        this.tripDistance = tripDistance;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public double getTripDistance() {
+        return tripDistance;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        RentInfo rent = (RentInfo) o;
+        return Double.compare(rent.tripDistance, tripDistance) == 0
+            && Objects.equals(type, rent.type);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(type, tripDistance);
+    }
+}
diff --git a/src/main/java/oilinjection/util/Parser.java b/src/main/java/oilinjection/util/Parser.java
new file mode 100644
index 00000000..5829ea8a
--- /dev/null
+++ b/src/main/java/oilinjection/util/Parser.java
@@ -0,0 +1,41 @@
+package oilinjection.util;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import oilinjection.domain.vo.RentInfo;
+
+public class Parser {
+
+    private static final String RESERVATION_DELIMITER = ",";
+    private static final String INFO_DELIMITER = ":";
+    private static final int TYPE = 0;
+    private static final int TRIP_DISTANCE = 1;
+    private static final String INPUT_FORMAT_REGEX = "[a-zA-z0-9]+:[0-9]+";
+    private static final String INVALID_FORMAT_EXCEPTION_MESSAGE = "[ERROR] 입력 형식이 맞지 않습니다(eg.${carType}:${tripDistance})";
+
+    public static List<RentInfo> parse(final String input) {
+
+        final String[] rentInfos = input.split(RESERVATION_DELIMITER);
+
+        return Collections.unmodifiableList(
+            Arrays.stream(rentInfos)
+                .map(rentInfo -> {
+                    validateInfoFormat(rentInfo);
+                    return createRentInfo(rentInfo);
+                })
+                .collect(Collectors.toList()));
+    }
+
+    private static void validateInfoFormat(final String rent) {
+        if (!rent.matches(INPUT_FORMAT_REGEX)) {
+            throw new IllegalArgumentException(INVALID_FORMAT_EXCEPTION_MESSAGE);
+        }
+    }
+
+    private static RentInfo createRentInfo(final String rentInfo) {
+        final String[] split = rentInfo.split(INFO_DELIMITER);
+        return new RentInfo(split[TYPE], Double.parseDouble(split[TRIP_DISTANCE]));
+    }
+}
diff --git a/src/main/java/oilinjection/view/InputView.java b/src/main/java/oilinjection/view/InputView.java
new file mode 100644
index 00000000..7108845f
--- /dev/null
+++ b/src/main/java/oilinjection/view/InputView.java
@@ -0,0 +1,26 @@
+package oilinjection.view;
+
+import java.util.Scanner;
+
+public class InputView {
+
+    private static final Scanner SCANNER = new Scanner(System.in);
+    private static final String RESERVATION_INFO_INPUT_MESSAGE = "대여할 자동차와 예상 거리를 입력해 주세요. (eg. carType1:distance, carType2:distance)";
+    private static final String ALL_SPACE = "\\s+";
+    private static final String EMPTY_STRING = "";
+
+    private InputView() {}
+
+    public static String inputReservationInfo() {
+        System.out.println(RESERVATION_INFO_INPUT_MESSAGE);
+        return input();
+    }
+
+    private static String input() {
+        return removeSpace(SCANNER.nextLine());
+    }
+
+    private static String removeSpace(final String input) {
+        return input.replaceAll(ALL_SPACE, EMPTY_STRING);
+    }
+}
diff --git a/src/main/java/oilinjection/view/ResultView.java b/src/main/java/oilinjection/view/ResultView.java
new file mode 100644
index 00000000..b83268be
--- /dev/null
+++ b/src/main/java/oilinjection/view/ResultView.java
@@ -0,0 +1,8 @@
+package oilinjection.view;
+
+public class ResultView {
+
+    public static void print(final String report) {
+        System.out.print(report);
+    }
+}
diff --git a/src/test/java/blackjack/domain/card/CardTest.java b/src/test/java/blackjack/domain/card/CardTest.java
new file mode 100644
index 00000000..d4062440
--- /dev/null
+++ b/src/test/java/blackjack/domain/card/CardTest.java
@@ -0,0 +1,27 @@
+package blackjack.domain.card;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class CardTest {
+
+    @DisplayName("카드 이름을 반환한다.")
+    @Test
+    void When카드이름_얻기_Then이름_반환() {
+        assertThat(new Card(Pattern.SPADE, Rank.SEVEN).getName()).isEqualTo("7스페이드");
+    }
+
+    @DisplayName("ACE이면 true 반환한다.")
+    @Test
+    void Given에이스_When판단_Then참() {
+        assertThat(new Card(Pattern.SPADE, Rank.ACE).isAce()).isTrue();
+    }
+
+    @DisplayName("ACE가 아니면 false를 반환한다.")
+    @Test
+    void Given에이스_이외의_카드_When판단_Then거짓() {
+        assertThat(new Card(Pattern.SPADE, Rank.KING).isAce()).isFalse();
+    }
+}
diff --git a/src/test/java/blackjack/domain/card/CardsTest.java b/src/test/java/blackjack/domain/card/CardsTest.java
new file mode 100644
index 00000000..ae1eba7a
--- /dev/null
+++ b/src/test/java/blackjack/domain/card/CardsTest.java
@@ -0,0 +1,68 @@
+package blackjack.domain.card;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class CardsTest {
+
+    private Cards sut;
+
+    @BeforeEach
+    void before() {
+        sut = new Cards();
+    }
+
+    @DisplayName("카드 한장을 뽑는다.")
+    @Test
+    void GivenNothing_When카드_뽑기_Then카드() {
+        // When
+        final Card card = sut.draw();
+
+        // Then
+        assertThat(card).isNotNull();
+    }
+
+    @DisplayName("카드를 뽑을때 남은 카드가 없으면 예외를 발생시킨다.")
+    @Test
+    void Given빈_덱_When카드_뽑기_Then예외_발생() {
+        // Given
+        final List<Card> cards = Arrays.stream(Pattern.values())
+            .flatMap(pattern ->
+                Arrays.stream(Rank.values())
+                    .map(rank -> new Card(pattern, rank))
+                    .collect(Collectors.toList()).stream())
+            .collect(Collectors.toList());
+
+        for (Card card : cards) {
+            sut = sut.remove(card);
+        }
+
+        // When & Then
+        assertThatExceptionOfType(IllegalArgumentException.class)
+            .isThrownBy(() -> sut.draw());
+    }
+
+    @DisplayName("카드를 전부 뽑아 덱이 제대로 생성되었는지 확인한다.")
+    @Test
+    void GivenNothing_When카드_전부_뽑기_Then중복되지_않은_모든_카드() {
+        // When
+        final Set<Card> cards = IntStream.range(0, 52).mapToObj(i -> {
+                Card card = sut.draw();
+                sut.remove(card);
+                return card;
+            })
+            .collect(Collectors.toSet());
+
+        // Then
+        assertThat(cards.size()).isEqualTo(52);
+    }
+}
diff --git a/src/test/java/blackjack/domain/card/DeckTest.java b/src/test/java/blackjack/domain/card/DeckTest.java
new file mode 100644
index 00000000..41d54a86
--- /dev/null
+++ b/src/test/java/blackjack/domain/card/DeckTest.java
@@ -0,0 +1,48 @@
+package blackjack.domain.card;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class DeckTest {
+
+    private Deck sut;
+
+    @BeforeEach
+    void before() {
+        sut = new Deck();
+    }
+
+    @DisplayName("카드를 한장 뽑는다.")
+    @Test
+    void GivenNothing_When_Then() {
+        assertThat(sut.draw()).isNotNull();
+    }
+
+    @DisplayName("참가자들의 초기 패를 뽑는다.")
+    @Test
+    void Given_When_Then() {
+        assertThat(sut.dealCards().size()).isEqualTo(2);
+    }
+
+    @DisplayName("중복없이 모든 카드가 뽑힌다.")
+    @Test
+    void GivenNothing_When카드_전부_뽑기_Then중복되지_않은_모든_카드() {
+
+        // When
+        final Set<Card> cards = IntStream.range(0, 52)
+            .mapToObj(i -> {
+                Card card = sut.draw();
+                return card;
+            })
+            .collect(Collectors.toSet());
+
+        // Then
+        assertThat(cards.size()).isEqualTo(52);
+    }
+}
diff --git a/src/test/java/blackjack/domain/card/HandsTest.java b/src/test/java/blackjack/domain/card/HandsTest.java
new file mode 100644
index 00000000..d99fcb02
--- /dev/null
+++ b/src/test/java/blackjack/domain/card/HandsTest.java
@@ -0,0 +1,76 @@
+package blackjack.domain.card;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class HandsTest {
+
+    @DisplayName("참가자 패의 카드 값을 더해 반환한다.")
+    @Test
+    void Given카드_2장_When합_구하기_Then합_반환() {
+        // Given
+        final Hands hands = new Hands(Arrays.asList(
+            new Card(Pattern.CLUB, Rank.TEN),
+            new Card(Pattern.SPADE, Rank.TEN)));
+
+        // Then
+        assertThat(hands.getScore()).isEqualTo(20);
+    }
+
+    @DisplayName("초기에 ACE를 한장 가지고 있는 경우 ACE를 11로 계산한다.")
+    @Test
+    void GivenAce_한_장_포함된_카드_2장_When합_구하기_Then합_반환() {
+        // Given
+        final Hands hands = new Hands(Arrays.asList(
+            new Card(Pattern.CLUB, Rank.ACE),
+            new Card(Pattern.SPADE, Rank.TEN)));
+
+        // Then
+        assertThat(hands.getScore()).isEqualTo(21);
+    }
+
+    @DisplayName("초기에 ACE를 2장 갖고 있는 경우, 합을 12로 계산한다.")
+    @Test
+    void GivenAce_2장_When합_구하기_Then합_반환() {
+        // Given
+        final Hands hands = new Hands(Arrays.asList(
+            new Card(Pattern.CLUB, Rank.ACE),
+            new Card(Pattern.SPADE, Rank.ACE)));
+
+        // Then
+        assertThat(hands.getScore()).isEqualTo(12);
+    }
+
+    @DisplayName("참가자의 카드 패에 ACE를 추가할 때 11로 더해도 21을 넘지 않으면 ACE를 11로 계산한다.")
+    @Test
+    void GivenAce_When합_구하기_Then11을_더한_스코어() {
+        // Given
+        final Hands hands = new Hands(Arrays.asList(
+            new Card(Pattern.CLUB, Rank.TWO),
+            new Card(Pattern.SPADE, Rank.TWO)));
+
+        // When
+        hands.add(new Card(Pattern.CLUB, Rank.ACE));
+
+        // Then
+        assertThat(hands.getScore()).isEqualTo(15);
+    }
+
+    @DisplayName("참가자의 카드 패에 ACE를 추가할 때 11을 더헀을 때, 21을 넘으면 ACE를 1로 계산한다.")
+    @Test
+    void GivenAce_When합_구하기_Then1을_더한_스코어() {
+        // Given
+        final Hands hands = new Hands(Arrays.asList(
+            new Card(Pattern.CLUB, Rank.TEN),
+            new Card(Pattern.SPADE, Rank.TEN)));
+
+        // When
+        hands.add(new Card(Pattern.CLUB, Rank.ACE));
+
+        // Then
+        assertThat(hands.getScore()).isEqualTo(21);
+    }
+}
diff --git a/src/test/java/blackjack/domain/card/ScoreTest.java b/src/test/java/blackjack/domain/card/ScoreTest.java
new file mode 100644
index 00000000..9d83989f
--- /dev/null
+++ b/src/test/java/blackjack/domain/card/ScoreTest.java
@@ -0,0 +1,31 @@
+package blackjack.domain.card;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class ScoreTest {
+
+    @DisplayName("파라미터로 값이 없으면 초기 Score로 설정한다.")
+    @Test
+    void GivenNothing_When객체_생성_Then_초기_값을_가진_객체() {
+        assertThat(new Score().getValue()).isEqualTo(0);
+    }
+
+    @DisplayName("값을 받아 객체를 생성한다.")
+    @Test
+    void Given값_When객체_생성_Then넘겨받은_값을_가진_객체() {
+        assertThat(new Score(7).getValue()).isEqualTo(7);
+    }
+
+    @DisplayName("값을 받아 기존의 값과 더한 객체를 반환한다.")
+    @Test
+    void Given값_When객체_생성_Then기존_값과_들어온_값을_가진_객체() {
+        // Given
+        final Score score = new Score(1);
+
+        final Score newScore = score.sum(7);
+        assertThat(newScore.getValue()).isEqualTo(8);
+    }
+}
diff --git a/src/test/java/blackjack/domain/judge/JudgeTest.java b/src/test/java/blackjack/domain/judge/JudgeTest.java
new file mode 100644
index 00000000..dcbf565c
--- /dev/null
+++ b/src/test/java/blackjack/domain/judge/JudgeTest.java
@@ -0,0 +1,101 @@
+package blackjack.domain.judge;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Pattern;
+import blackjack.domain.card.Rank;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Player;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class JudgeTest {
+
+    private final List<Card> score16 = Arrays.asList(
+        new Card(Pattern.CLUB, Rank.TEN),
+        new Card(Pattern.HEART, Rank.SIX));
+
+    private final List<Card> score21 = Arrays.asList(
+        new Card(Pattern.DIAMOND, Rank.ACE),
+        new Card(Pattern.HEART, Rank.TEN));
+
+    private final List<Card> score26 = Arrays.asList(
+        new Card(Pattern.DIAMOND, Rank.TEN),
+        new Card(Pattern.HEART, Rank.SIX),
+        new Card(Pattern.HEART, Rank.TEN));
+
+    private final Judge judge = new Judge();
+
+    private final Map<String, String> playerWin = new HashMap() {
+        {
+            put("딜러", "0승 1패");
+            put("jason", "승");
+        }
+    };
+
+    private final Map<String, String> dealerWin = new HashMap() {
+        {
+            put("딜러", "1승 0패");
+            put("jason", "패");
+        }
+    };
+
+    @DisplayName("플레이어가 딜러보다 점수가 높으면 플레이어가 승리한다.")
+    @Test
+    void Given플레이어_딜러_점수_When플레이어가_높은_Then플레이어_승리() {
+        final Dealer dealer = new Dealer(score16);
+        final Player player = new Player("jason", score21);
+
+        assertThat(judge.getWinOrLose(dealer, Arrays.asList(player))).isEqualTo(playerWin);
+    }
+
+    @DisplayName("플레이어가 딜러보다 점수가 낮으면 딜러가 승리한다.")
+    @Test
+    void Given플레이어_딜러_점수_When딜러가_높은_The딜러_승리() {
+        final Dealer dealer = new Dealer(score21);
+        final Player player = new Player("jason", score16);
+
+        assertThat(judge.getWinOrLose(dealer, Arrays.asList(player))).isEqualTo(dealerWin);
+    }
+
+    @DisplayName("딜러와 플레이어가 모두 21을 넘었을 때, 딜러가 승리한다.")
+    @Test
+    void Given플레이어_딜러_점수_When둘다_21_초과_The딜러_승리() {
+        final Dealer dealer = new Dealer(score26);
+        final Player player = new Player("jason", score26);
+
+        assertThat(judge.getWinOrLose(dealer, Arrays.asList(player))).isEqualTo(dealerWin);
+    }
+
+    @DisplayName("딜러는 21을 넘고, 플레이어는 넘지 않았으면 플레이어가 승리한다.")
+    @Test
+    void Given플레이어_딜러_점수When딜러_21_초과_The플레이어_승리() {
+        final Dealer dealer = new Dealer(score26);
+        final Player player = new Player("jason", score16);
+
+        assertThat(judge.getWinOrLose(dealer, Arrays.asList(player))).isEqualTo(playerWin);
+    }
+
+    @DisplayName("플레이어는 21을 넘고, 딜러는 넘지 않았으면 딜러가 승리한다.")
+    @Test
+    void Given플레이어_딜러_점수When플레이어_21_초과_The딜러_승리() {
+        final Dealer dealer = new Dealer(score21);
+        final Player player = new Player("jason", score26);
+
+        assertThat(judge.getWinOrLose(dealer, Arrays.asList(player))).isEqualTo(dealerWin);
+    }
+
+    @DisplayName("플레이어와 딜러의 점수가 같으면 딜러가 승리한다.")
+    @Test
+    void Given플레이어_딜러_점수When같다_The딜러_승리() {
+        final Dealer dealer = new Dealer(score21);
+        final Player player = new Player("jason", score21);
+
+        assertThat(judge.getWinOrLose(dealer, Arrays.asList(player))).isEqualTo(dealerWin);
+    }
+}
diff --git a/src/test/java/blackjack/domain/participant/DealerTest.java b/src/test/java/blackjack/domain/participant/DealerTest.java
new file mode 100644
index 00000000..8dbb33b6
--- /dev/null
+++ b/src/test/java/blackjack/domain/participant/DealerTest.java
@@ -0,0 +1,47 @@
+package blackjack.domain.participant;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Hands;
+import blackjack.domain.card.Pattern;
+import blackjack.domain.card.Rank;
+import java.util.Arrays;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class DealerTest {
+
+    @DisplayName("플레이어의 현재 점수를 가져온다.")
+    @Test
+    void Given카드들_When점수_얻기_Then점수_합_반환() {
+        final Dealer dealer = new Dealer(
+            Arrays.asList(
+                new Card(Pattern.CLUB, Rank.EIGHT),
+                new Card(Pattern.SPADE, Rank.EIGHT)));
+
+        assertThat(dealer.getScore()).isEqualTo(16);
+    }
+
+    @DisplayName("카드를 한장 더 받을 수 있다.")
+    @Test
+    void Given카드들_When점수가_17미만_Then참_반환() {
+        final Dealer dealer = new Dealer(
+            Arrays.asList(
+                new Card(Pattern.CLUB, Rank.EIGHT),
+                new Card(Pattern.HEART, Rank.FIVE)));
+
+        assertThat(dealer.canDraw()).isTrue();
+    }
+
+    @DisplayName("카드를 한장 더 받을 수 없다.")
+    @Test
+    void Given카드들_When점수가_17이상_Then거짓_반환() {
+        final Dealer dealer = new Dealer(
+            Arrays.asList(
+                new Card(Pattern.CLUB, Rank.TEN),
+                new Card(Pattern.HEART, Rank.ACE)));
+
+        assertThat(dealer.canDraw()).isFalse();
+    }
+}
diff --git a/src/test/java/blackjack/domain/participant/PlayerTest.java b/src/test/java/blackjack/domain/participant/PlayerTest.java
new file mode 100644
index 00000000..38db73be
--- /dev/null
+++ b/src/test/java/blackjack/domain/participant/PlayerTest.java
@@ -0,0 +1,46 @@
+package blackjack.domain.participant;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import blackjack.domain.card.Card;
+import blackjack.domain.card.Pattern;
+import blackjack.domain.card.Rank;
+import java.util.Arrays;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class PlayerTest {
+
+    @DisplayName("플레이어의 현재 점수를 가져온다.")
+    @Test
+    void Given카드들_When점수_얻기_Then점수_합_반환() {
+        final Player player = new Player("jason",
+            Arrays.asList(
+                new Card(Pattern.CLUB, Rank.EIGHT),
+                new Card(Pattern.SPADE, Rank.EIGHT)));
+
+        assertThat(player.getScore()).isEqualTo(16);
+    }
+
+    @DisplayName("카드를 한장 더 받을 수 있다.")
+    @Test
+    void Given카드들_When점수가_21미만_Then참_반환() {
+        final Player player = new Player("jason",
+            Arrays.asList(
+                new Card(Pattern.CLUB, Rank.EIGHT),
+                new Card(Pattern.HEART, Rank.FIVE)));
+
+        assertThat(player.canDraw()).isTrue();
+    }
+
+    @DisplayName("카드를 한장 더 받을 수 없다.")
+    @Test
+    void Given카드들_When점수가_21이상_Then거짓_반환() {
+        final Player player = new Player("jason",
+            Arrays.asList(
+                new Card(Pattern.CLUB, Rank.TEN),
+                new Card(Pattern.HEART, Rank.ACE)));
+
+        assertThat(player.canDraw()).isFalse();
+    }
+}
diff --git a/src/test/java/blackjack/util/ParserTest.java b/src/test/java/blackjack/util/ParserTest.java
new file mode 100644
index 00000000..4f580b40
--- /dev/null
+++ b/src/test/java/blackjack/util/ParserTest.java
@@ -0,0 +1,29 @@
+package blackjack.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class ParserTest {
+
+    @DisplayName("플레이어의 이름을 정상적으로 반환한다.")
+    @Test
+    void Given유효한값_When파싱_Then이름_반환() {
+        final List<String> names = Parser.parse(" json, pobi ");
+        assertThat(names).isEqualTo(Arrays.asList("json","pobi"));
+    }
+
+    @DisplayName("플레이어의 이름이 하나라도 빈 값이면 예외를 발생시칸다.")
+    @ValueSource(strings = {"kim, ,jun", "", ",", " , ", "kim,", ",kim", ",,kim", "kim,,", "kim, ,"})
+    @ParameterizedTest
+    void Given빈_값_When파싱_Then예외_발생(String input) {
+        assertThatExceptionOfType(IllegalArgumentException.class)
+            .isThrownBy(() -> Parser.parse(input));
+    }
+}
diff --git a/src/test/java/empty.txt b/src/test/java/empty.txt
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/test/java/oilinjection/domain/RentCarTest.java b/src/test/java/oilinjection/domain/RentCarTest.java
new file mode 100644
index 00000000..9a3a7efa
--- /dev/null
+++ b/src/test/java/oilinjection/domain/RentCarTest.java
@@ -0,0 +1,59 @@
+package oilinjection.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+import oilinjection.domain.car.Avante;
+import oilinjection.domain.car.Car;
+import oilinjection.domain.car.K5;
+import oilinjection.domain.car.Sonata;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+public class RentCarTest {
+
+    @DisplayName("Avante를 반환한다.")
+    @Test
+    void 아반떼_생성() {
+        final Car avante = RentCar.rent("avante", 200D);
+        assertThat(avante).isEqualTo(new Avante(200D));
+    }
+
+    @DisplayName("K5 반환한다.")
+    @Test
+    void K5_생성() {
+        final Car k5 = RentCar.rent("K5", 200D);
+        assertThat(k5).isEqualTo(new K5(200D));
+    }
+
+    @DisplayName("Sonata를 반환한다.")
+    @Test
+    void 소나타_생성() {
+        final Car sonata = RentCar.rent("sonata", 200D);
+        assertThat(sonata).isEqualTo(new Sonata(200D));
+    }
+
+    @DisplayName("해당하는 차종이 없으면 예외를 발생시킨다.")
+    @Test
+    void 차종_없음() {
+        assertThatExceptionOfType(IllegalArgumentException.class)
+            .isThrownBy(() -> RentCar.rent("none", 10D));
+    }
+
+    @DisplayName("예약 하는 여행 거리가 최소 거리(1) 보다 작으면 예외가 발생한다.")
+    @Test
+    void 최소_거리보다_작음() {
+        assertThatExceptionOfType(IllegalArgumentException.class)
+            .isThrownBy(() -> RentCar.rent("avante", 0D));
+    }
+
+    @DisplayName("자동차의 차종은 대소문자를 구분하지 않는다.")
+    @ValueSource(strings = {"Sonata", "sOnAtA", "SONATA"})
+    @ParameterizedTest
+    void 소나타_대소문자_구분없이_생성(final String name) {
+        final Car sonata = RentCar.rent(name, 200D);
+        assertThat(sonata).isEqualTo(new Sonata(200D));
+    }
+}
diff --git a/src/test/java/oilinjection/domain/RentCompanyTest.java b/src/test/java/oilinjection/domain/RentCompanyTest.java
new file mode 100644
index 00000000..7a102708
--- /dev/null
+++ b/src/test/java/oilinjection/domain/RentCompanyTest.java
@@ -0,0 +1,64 @@
+package oilinjection.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+import java.util.Arrays;
+import java.util.List;
+import oilinjection.domain.vo.RentInfo;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class RentCompanyTest {
+
+    private static final String NEWLINE = System.getProperty("line.separator");
+
+    @DisplayName("정상적인 렌트카 예약을 받는다.")
+    @Test
+    void 정상적인_렌트카_예약() {
+        final List<RentInfo> reservation = Arrays.asList(
+            new RentInfo("avante", 200D),
+            new RentInfo("K5", 100D));
+
+        final RentCompany rentCompany = new RentCompany();
+
+        assertDoesNotThrow(() -> rentCompany.acceptReservation(reservation));
+    }
+
+    @DisplayName("소유하고 있는 렌트카보다 많은 수를 예약하면 예외를 발생시킨다.")
+    @Test
+    void 소유한_렌트카_수보다_많은_예약() {
+        final List<RentInfo> reservation = Arrays.asList(
+            new RentInfo("avante", 200D),
+            new RentInfo("avante", 100D));
+
+        final RentCompany rentCompany = new RentCompany();
+
+        assertThatExceptionOfType(IllegalArgumentException.class)
+            .isThrownBy(() -> rentCompany.acceptReservation(reservation));
+    }
+
+    @DisplayName("차량별로 주입해야할 연료량을 확인할 수 있는 보고서를 생성한다.")
+    @Test
+    void 보고서_생성() {
+        final List<RentInfo> reservation = Arrays.asList(
+            new RentInfo("Avante", 20D),
+            new RentInfo("Sonata", 300D),
+            new RentInfo("Sonata", 150D),
+            new RentInfo("K5", 130D),
+            new RentInfo("K5", 390D));
+
+        final RentCompany rentCompany = new RentCompany();
+        rentCompany.acceptReservation(reservation);
+        String report = rentCompany.createReport();
+
+        assertThat(report).isEqualTo(
+            "Avante : 2리터" + NEWLINE +
+            "Sonata : 30리터" + NEWLINE +
+            "Sonata : 15리터" + NEWLINE +
+            "K5 : 10리터" + NEWLINE +
+            "K5 : 30리터" + NEWLINE
+        );
+    }
+}
diff --git a/src/test/java/oilinjection/domain/car/AvanteTest.java b/src/test/java/oilinjection/domain/car/AvanteTest.java
new file mode 100644
index 00000000..f5af99df
--- /dev/null
+++ b/src/test/java/oilinjection/domain/car/AvanteTest.java
@@ -0,0 +1,16 @@
+package oilinjection.domain.car;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class AvanteTest {
+
+    @DisplayName("아반떼의 주입 해야할 연료량을 구한다.")
+    @Test
+    void 아반떼_필요한_연료량() {
+        final Car avante = new Avante(300D);
+        assertThat(avante.getChargeQuantity()).isEqualTo(20D);
+    }
+}
diff --git a/src/test/java/oilinjection/domain/car/K5Test.java b/src/test/java/oilinjection/domain/car/K5Test.java
new file mode 100644
index 00000000..427a01f6
--- /dev/null
+++ b/src/test/java/oilinjection/domain/car/K5Test.java
@@ -0,0 +1,16 @@
+package oilinjection.domain.car;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class K5Test {
+
+    @DisplayName("K5의 주입해야할 연료량을 구한다.")
+    @Test
+    void K5_필요한_연료량() {
+        final Car k5 = new K5(260D);
+        assertThat(k5.getChargeQuantity()).isEqualTo(20D);
+    }
+}
diff --git a/src/test/java/oilinjection/domain/car/SonataTest.java b/src/test/java/oilinjection/domain/car/SonataTest.java
new file mode 100644
index 00000000..dffcd4a7
--- /dev/null
+++ b/src/test/java/oilinjection/domain/car/SonataTest.java
@@ -0,0 +1,16 @@
+package oilinjection.domain.car;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class SonataTest {
+
+    @DisplayName("소나타의 주입해야할 연료량을 구한다.")
+    @Test
+    void 소나타_필요_연료량() {
+        final Car sonata = new Sonata(200D);
+        assertThat(sonata.getChargeQuantity()).isEqualTo(20D);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/oilinjection/util/ParserTest.java b/src/test/java/oilinjection/util/ParserTest.java
new file mode 100644
index 00000000..b1826534
--- /dev/null
+++ b/src/test/java/oilinjection/util/ParserTest.java
@@ -0,0 +1,63 @@
+package oilinjection.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.List;
+import oilinjection.domain.vo.RentInfo;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+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 ParserTest {
+
+    @DisplayName("올바른 입력이 들어오면, 정상적으로 실행된다.")
+    @Test
+    void 정상_입력1() {
+        final String input = "car1:200";
+        final RentInfo rent = new RentInfo("car1", 200);
+        assertThat(Parser.parse(input)).isEqualTo(Arrays.asList(rent));
+    }
+
+    @DisplayName("두 개 이상의 rent 정보가 올바른 입력 형식으로 들어와도 정상적으로 실행된다.")
+    @Test
+    void 정상_입력2() {
+        final String input = "car1:200,car2:300";
+        final List<RentInfo> rents = Arrays.asList(new RentInfo("car1", 200), new RentInfo("car2", 300));
+        assertThat(Parser.parse(input)).isEqualTo(rents);
+    }
+
+    @DisplayName("입력이 빈 값이면 예외가 발생한다.")
+    @EmptySource
+    @ParameterizedTest
+    void 빈_입력_예외_발생(final String input) {
+        Assertions.assertThatExceptionOfType(IllegalArgumentException.class)
+            .isThrownBy(() -> Parser.parse(input));
+    }
+
+    @DisplayName("랜트 정보 값이 하나로도 빈 값이면 예외가 발생한다.")
+    @ValueSource(strings = {"car1:", ":200"})
+    @ParameterizedTest
+    void 렌트_정보_중_하나의_빈_입력_예외_발생(final String input) {
+        Assertions.assertThatExceptionOfType(IllegalArgumentException.class)
+            .isThrownBy(() -> Parser.parse(input));
+    }
+
+    @DisplayName("랜트 정보 중 거리 값이 숫자가 아니면 예외가 발생한다.")
+    @Test
+    void 거리_값이_숫자가_아닌_경우_예외_발생() {
+        Assertions.assertThatExceptionOfType(IllegalArgumentException.class)
+            .isThrownBy(() -> Parser.parse("car:aaa"));
+    }
+
+    @DisplayName("입력 형식에 맞지 않는 경우 예외가 발생한다.")
+    @ValueSource(strings = {"car1 200", "car1,200", "card1200", "car::123"})
+    @ParameterizedTest
+    void 입력_형식에_맞지_않는_경우_예외_발생(final String input) {
+        Assertions.assertThatExceptionOfType(IllegalArgumentException.class)
+            .isThrownBy(() -> Parser.parse(input));
+    }
+}