diff --git a/.gitignore b/.gitignore
index 492f742..bf433ff 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 .idea/**
 .gradle/**
-build/
+build/**
+out/**
diff --git a/README.md b/README.md
index 42fb362..1746eb2 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,37 @@
 # java-ladder 게임
+
+## 기능 목록
+
+- 사용자로부터 입력 받기
+    
+    - 이름은 쉼표를 기준으로 한다.
+    
+        - 이름은 최대 5글자까지
+    
+    - 최대 사다리 높이를 받아야 한다.
+    
+        - 높이는 1이상
+        
+    - 사다리 상품을 입력 받는다.
+        
+        - 입력 받은 상품의 수와 이름의 수가 같아야 한다. (에러 팡)
+
+- 사다리 만들기
+    
+    - 이름 길이 5 기준으로 사다리 폭이 정해진다.
+    
+    - 사다리 라인이 겹치지 않도록 해야한다.
+    
+- 사다리 게임 실행하기
+
+- 사다리 출력하기
+ 
+    - 사용자 이름, 사다리 그리고 상품 이름을 함께 출력해야한다.
+    
+    - 결과를 보여준다.
+        
+        - 한 사람을 물어보면 그 사람 결과를 보여준다.
+        
+        - all 이라 입력하면 전체 결과를 보여준다.
+        
+        - 없는 사람을 물어보면 없다는 메세지를 보여준다.  
\ No newline at end of file
diff --git a/src/main/java/Application.java b/src/main/java/Application.java
new file mode 100644
index 0000000..811fe9c
--- /dev/null
+++ b/src/main/java/Application.java
@@ -0,0 +1,10 @@
+public class Application {
+  public static void main(String[] args) {
+    LadderGameInputData ladderGameInputData = ConsoleInput.getLadderGameInputData();
+    LadderGame ladderGame = LadderGame.with(ladderGameInputData, new RandomRowGeneratorStrategy());
+    ladderGame.generateLadder();
+    ladderGame.run();
+    LadderGameOutputData ladderGameOutputData = ladderGame.getLadderGameOutputData();
+    ConsoleOutput.showLadderGameResultWith(ladderGameOutputData);
+  }
+}
diff --git a/src/main/java/ConsoleInput.java b/src/main/java/ConsoleInput.java
new file mode 100644
index 0000000..8ef3b44
--- /dev/null
+++ b/src/main/java/ConsoleInput.java
@@ -0,0 +1,80 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class ConsoleInput {
+
+  public static final int INITIAL_POSITION = 0;
+  public static final String DELIMITER = ",";
+  public static final String MESSAGE_INPUT_USER_NAMES = "참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요.)";
+  public static final String MESSAGE_INPUT_MAX_LADDER_HEIGHT = "최대 사다리 높이는 몇 개인가요?";
+  public static final String MESSAGE_INPUT_GAME_PRIZES = "사다리 상품을 입력해주세요.(상품들은 쉼표(,)로 구분됩니다.)";
+  public static final String ERROR_INPUT_NOT_INTEGER = "정수를 입력하셔야 합니다.";
+
+  public static Scanner sc = new Scanner(System.in);
+
+  public static LadderGameInputData getLadderGameInputData() {
+    List<User> users = createUsersFrom(getInputUserNames());
+    LadderHeight height = createHeight();
+    List<Prize> prizes = createPrizesFrom(getInputPrizeNames());
+    return LadderGameInputData.of(users, height, prizes);
+  }
+
+  private static List<String> getInputPrizeNames() {
+    System.out.println(MESSAGE_INPUT_GAME_PRIZES);
+    return Arrays.asList(sc.nextLine().split(DELIMITER));
+  }
+
+  static List<Prize> createPrizesFrom(List<String> prizeNames) {
+    List<Prize> prizes = new ArrayList<>();
+
+    int position = INITIAL_POSITION;
+    for (String prizeName: prizeNames) {
+      Prize prize = Prize.with(prizeName, position);
+      prizes.add(prize);
+      position++;
+    }
+    return prizes;
+  }
+
+  private static List<String> getInputUserNames() {
+    System.out.println(MESSAGE_INPUT_USER_NAMES);
+    return Arrays.asList(sc.nextLine().split(DELIMITER));
+  }
+
+  static List<User> createUsersFrom(List<String> userNames) {
+    List<User> users = new ArrayList<>();
+
+    int position = INITIAL_POSITION;
+    for (String userName: userNames) {
+      User user = User.with(UserName.of(userName), position);
+      users.add(user);
+      position++;
+    }
+    return users;
+  }
+
+  private static LadderHeight createHeight() {
+    System.out.println(MESSAGE_INPUT_MAX_LADDER_HEIGHT);
+    return LadderHeight.of(getInputHeight());
+  }
+
+  private static int getInputHeight() {
+    String height = sc.nextLine();
+    if (isConvertibleIntoInteger(height)) {
+     return Integer.parseInt(height);
+    }
+    throw new IllegalArgumentException(ERROR_INPUT_NOT_INTEGER);
+  }
+
+  public static boolean isConvertibleIntoInteger(String str) {
+    for (char c: str.toCharArray()) {
+      if (c < 48 || c > 57) {
+        System.out.println(c);
+        return false;
+      }
+    }
+    return true;
+  }
+}
diff --git a/src/main/java/ConsoleOutput.java b/src/main/java/ConsoleOutput.java
new file mode 100644
index 0000000..5ebb817
--- /dev/null
+++ b/src/main/java/ConsoleOutput.java
@@ -0,0 +1,93 @@
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+
+public class ConsoleOutput {
+
+  public static final String MESSAGE_LADDER_GAME_RESULT = "사다리 결과";
+  public static final String NULL = "\0";
+  public static final String BLANK_BETWEEN_NAMES = "  ";
+  public static final String NEXT_LINE = "\n";
+  public static final String INITIAL_STRING = "";
+  public static final String BAR = "|";
+  public static final String LEFT_MARGIN = "   ";
+  public static final String BLANK = " ";
+  private static final int MAXIMUM_LENGTH = 5;
+  public static final String DELIMITER = " : ";
+  public static final String ALL = "all";
+  public static final String MESSAGE_NOT_PARTICIPANT = "참가한 유저가 아닙니다.";
+  public static final String MESSAGE_WANT_TO_KNOW = "결과를 보고 싶은 사람은?";
+
+  public static Scanner sc = new Scanner(System.in);
+
+  public static void showLadderGameResultWith(LadderGameOutputData ladderGameOutputData) {
+    showLadderGame(ladderGameOutputData.getUsers(), ladderGameOutputData.getLadder(), ladderGameOutputData.getPrizes());
+    showGameResult(ladderGameOutputData.getLadderResult());
+  }
+
+  private static void showLadderGame(List<User> users, Ladder ladder, List<Prize> prizes) {
+    System.out.println(MESSAGE_LADDER_GAME_RESULT);
+    showUsers(users);
+    showLadder(ladder);
+    showPrizes(prizes);
+  }
+
+  private static void showUsers(List<User> users) {
+    users.forEach(user -> showNameToMaximumLength(user.getUserName().getName()));
+    System.out.print(NEXT_LINE);
+  }
+
+  private static void showPrizes(List<Prize> prizes) {
+   prizes.forEach(prize -> showNameToMaximumLength(prize.getPrizeName()));
+   System.out.print(NEXT_LINE);
+  }
+
+  private static void showNameToMaximumLength(String name) {
+    int blankSpaceNums = MAXIMUM_LENGTH - name.length();
+    String blank = new String(new char[blankSpaceNums]).replace(NULL, BLANK);
+    System.out.print(blank + name);
+    System.out.print(BLANK_BETWEEN_NAMES);
+ }
+
+  private static void showLadder(Ladder ladder) {
+    List<Row> rows = ladder.getRows();
+    rows.forEach(ConsoleOutput::showRow);
+  }
+
+  private static void showRow(Row row) {
+    System.out.print(LEFT_MARGIN);
+    String rowStr = INITIAL_STRING;
+    for (int position=0; position<row.getLenOfRow(); position++) {
+      String line = row.getLineStartingWith(position);
+      rowStr = rowStr.concat(BAR + line);
+    }
+    System.out.println(rowStr.concat(BAR));
+  }
+
+  private static void showGameResult(Map<User, Prize> prizes) {
+    System.out.println(MESSAGE_WANT_TO_KNOW);
+    String name = sc.nextLine();
+    if (name.equals(ALL)) {
+      showAllResult(prizes);
+      return;
+    }
+    showUserResult(name, prizes);
+  }
+
+  private static void showAllResult(Map<User,Prize> prizes) {
+    for (User user: prizes.keySet()) {
+      System.out.println(user.getUserName().getName() + DELIMITER + prizes.get(user).getPrizeName());
+    }
+  }
+
+  private static void showUserResult(String name, Map<User,Prize> prizes) {
+    UserName userName = UserName.of(name);
+    for (User user: prizes.keySet()) {
+      if (user.hasUserName(userName)) {
+        System.out.println(prizes.get(user).getPrizeName());
+        return;
+      }
+    }
+    System.out.println(MESSAGE_NOT_PARTICIPANT);
+  }
+}
diff --git a/src/main/java/Ladder.java b/src/main/java/Ladder.java
new file mode 100644
index 0000000..3667e43
--- /dev/null
+++ b/src/main/java/Ladder.java
@@ -0,0 +1,26 @@
+import java.util.List;
+
+public class Ladder {
+
+  private List<Row> rows;
+
+  private Ladder(List<Row> rows) {
+    this.rows = rows;
+  }
+
+  public static Ladder with(List<Row> rows) {
+    return new Ladder(rows);
+  }
+
+  public int startWith(int initialPosition) {
+    int position = initialPosition;
+    for (Row row: rows) {
+      position = row.getNextPosition(position);
+    }
+    return position;
+  }
+
+  public List<Row> getRows() {
+    return rows;
+  }
+}
diff --git a/src/main/java/LadderGame.java b/src/main/java/LadderGame.java
new file mode 100644
index 0000000..ec59e75
--- /dev/null
+++ b/src/main/java/LadderGame.java
@@ -0,0 +1,62 @@
+import java.util.HashMap;
+import java.util.List;
+
+public class LadderGame {
+
+  private List<User> users;
+  private LadderHeight height;
+  private List<Prize> prizes;
+  private Ladder ladder;
+  private LadderGenerator ladderGenerator;
+  private HashMap<User, Prize> ladderResult = new HashMap<>();
+
+  private LadderGame(LadderGameInputData ladderGameInputData, RowGeneratorStrategy rowGeneratorStrategy) {
+    this.users = ladderGameInputData.getUsers();
+    this.height = ladderGameInputData.getHeight();
+    this.prizes = ladderGameInputData.getPrizes();
+//   TODO 생성자에서 데이터를 넣어주느냐 vs 메서드 파라미터로 넣어주느냐 ( 각각 어떤 변화들을 야기하는가?!)
+//    TODO 파라미터로 넣어주면 generateRows에 자유도가 생김.
+    this.ladderGenerator = new LadderGenerator(rowGeneratorStrategy);
+  }
+
+  public static LadderGame with(LadderGameInputData ladderGameInputData, RowGeneratorStrategy rowGeneratorStrategy) {
+    return new LadderGame(ladderGameInputData, rowGeneratorStrategy);
+  }
+
+  public void generateLadder() {
+    int numOfColumn = users.size();
+    ladder = ladderGenerator.generateLadder(numOfColumn, height.getHeight());
+  }
+
+  public void run() {
+    users.forEach(this::runWith);
+  }
+
+  private void runWith(User user) {
+    int position = ladder.startWith(user.getPosition());
+    Prize prize = prizes.stream()
+        .filter(p -> p.hasPosition(position))
+        .findAny().orElseThrow(IllegalArgumentException::new);
+    ladderResult.put(user, prize);
+  }
+
+  public LadderGameOutputData getLadderGameOutputData() {
+    return LadderGameOutputData.of(users, prizes, ladder, ladderResult);
+  }
+
+  public List<User> getUsers() {
+    return users;
+  }
+
+  public LadderHeight getHeight() {
+    return height;
+  }
+
+  public LadderGenerator getLadderGenerator() {
+    return ladderGenerator;
+  }
+
+  public Ladder getLadder() {
+    return ladder;
+  }
+}
diff --git a/src/main/java/LadderGameInputData.java b/src/main/java/LadderGameInputData.java
new file mode 100644
index 0000000..db5808e
--- /dev/null
+++ b/src/main/java/LadderGameInputData.java
@@ -0,0 +1,39 @@
+import java.util.List;
+
+public class LadderGameInputData {
+
+  public static final String ERROR_USER_NUMS_PRIZE_NUMS_NOT_EQUAL = "참가자 수와 게임 상품 수가 일치하지 않습니다.";
+
+  private List<User> users;
+  private LadderHeight height;
+  private List<Prize> prizes;
+
+  private LadderGameInputData(List<User> users, LadderHeight height, List<Prize> prizes) {
+    validate(users, prizes);
+    this.users = users;
+    this.height = height;
+    this.prizes = prizes;
+  }
+
+  private void validate(List<User> users, List<Prize> prizes) {
+    if (users.size() != prizes.size()) {
+      throw new IllegalArgumentException(ERROR_USER_NUMS_PRIZE_NUMS_NOT_EQUAL);
+    }
+  }
+
+  public static LadderGameInputData of(List<User> users, LadderHeight height, List<Prize> prizes) {
+    return new LadderGameInputData(users, height, prizes);
+  }
+
+  public List<User> getUsers() {
+    return users;
+  }
+
+  public LadderHeight getHeight() {
+    return height;
+  }
+
+  public List<Prize> getPrizes() {
+    return prizes;
+  }
+}
diff --git a/src/main/java/LadderGameOutputData.java b/src/main/java/LadderGameOutputData.java
new file mode 100644
index 0000000..d7f6b1d
--- /dev/null
+++ b/src/main/java/LadderGameOutputData.java
@@ -0,0 +1,38 @@
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LadderGameOutputData {
+
+  private List<User> users;
+  private List<Prize> prizes;
+  private Ladder ladder;
+  private Map<User, Prize> ladderResult;
+
+  private LadderGameOutputData(List<User> users, List<Prize> prizes, Ladder ladder, Map<User, Prize> ladderResult) {
+    this.users = users;
+    this.prizes = prizes;
+    this.ladder = ladder;
+    this.ladderResult = ladderResult;
+  }
+
+  public static LadderGameOutputData of(List<User> users, List<Prize> prizes, Ladder ladder, HashMap<User,Prize> ladderResult) {
+    return new LadderGameOutputData(users, prizes, ladder, ladderResult);
+  }
+
+  public List<User> getUsers() {
+    return users;
+  }
+
+  public List<Prize> getPrizes() {
+    return prizes;
+  }
+
+  public Ladder getLadder() {
+    return ladder;
+  }
+
+  public Map<User, Prize> getLadderResult() {
+    return ladderResult;
+  }
+}
diff --git a/src/main/java/LadderGenerator.java b/src/main/java/LadderGenerator.java
new file mode 100644
index 0000000..a1737f2
--- /dev/null
+++ b/src/main/java/LadderGenerator.java
@@ -0,0 +1,33 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class LadderGenerator {
+
+  private RowGeneratorStrategy rowGeneratorStrategy;
+
+  public LadderGenerator(RowGeneratorStrategy rowGeneratorStrategy) {
+   this.rowGeneratorStrategy = rowGeneratorStrategy;
+  }
+
+  public static LadderGenerator with(RowGeneratorStrategy rowGeneratorStrategy) {
+    return new LadderGenerator(rowGeneratorStrategy);
+  }
+
+  public List<Row> generateRows(int numOfColumn, int height) {
+    List<Row> rows = new ArrayList<>();
+    int lenOfRow = numOfColumn - 1;
+    for (int i=0; i<height; i++) {
+      Row row = rowGeneratorStrategy.generateRow(lenOfRow);
+      rows.add(row);
+    }
+    return rows;
+  }
+
+  public Ladder generateLadder(int numOfColumn, int height) {
+    return Ladder.with(generateRows(numOfColumn, height));
+  }
+
+  public RowGeneratorStrategy getRowGeneratorStrategy() {
+    return rowGeneratorStrategy;
+  }
+}
diff --git a/src/main/java/LadderHeight.java b/src/main/java/LadderHeight.java
new file mode 100644
index 0000000..0dd5033
--- /dev/null
+++ b/src/main/java/LadderHeight.java
@@ -0,0 +1,26 @@
+public class LadderHeight {
+
+  public static final int THRESHOLD = 1;
+  public static final String ERROR_HEIGHT_SHORT = "사다리 높이가 1보다 작습니다.";
+
+  private final int height;
+
+  private LadderHeight(int height) {
+    validate(height);
+    this.height = height;
+  }
+
+  public static LadderHeight of(int height) {
+    return new LadderHeight(height);
+  }
+
+  private void validate(int height) {
+    if (height < THRESHOLD) {
+      throw new IllegalArgumentException(ERROR_HEIGHT_SHORT);
+    }
+  }
+  
+  public int getHeight() {
+    return height;
+  }
+}
diff --git a/src/main/java/Line.java b/src/main/java/Line.java
new file mode 100644
index 0000000..9b5d4e2
--- /dev/null
+++ b/src/main/java/Line.java
@@ -0,0 +1,46 @@
+import java.util.Objects;
+
+public class Line {
+
+  private final int startPosition;
+  private final int endPosition;
+
+  private Line(int startPosition, int endPosition) {
+    this.startPosition = startPosition;
+    this.endPosition = endPosition;
+  }
+
+  public static Line startWith(int startPosition) {
+    return new Line(startPosition, startPosition + 1);
+  }
+
+  public boolean isStartingWith(int position) {
+    return startPosition == position;
+  }
+
+  public boolean isEndingWith(int position) {
+    return endPosition == position;
+  }
+
+  public int getStartPosition() {
+    return startPosition;
+  }
+
+  public int getEndPosition() {
+    return endPosition;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    Line line = (Line) o;
+    return startPosition == line.startPosition &&
+        endPosition == line.endPosition;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(startPosition, endPosition);
+  }
+}
diff --git a/src/main/java/Prize.java b/src/main/java/Prize.java
new file mode 100644
index 0000000..dd77202
--- /dev/null
+++ b/src/main/java/Prize.java
@@ -0,0 +1,26 @@
+public class Prize {
+
+  private String prizeName;
+  private int position;
+
+  private Prize(String prizeName, int position) {
+    this.prizeName = prizeName;
+    this.position = position;
+  }
+
+  public static Prize with(String prizeName, int position) {
+    return new Prize(prizeName, position);
+  }
+
+  public String getPrizeName() {
+    return prizeName;
+  }
+
+  public int getPosition() {
+    return position;
+  }
+
+  public boolean hasPosition(int position) {
+    return this.position == position;
+  }
+}
diff --git a/src/main/java/RandomRowGeneratorStrategy.java b/src/main/java/RandomRowGeneratorStrategy.java
new file mode 100644
index 0000000..a83a045
--- /dev/null
+++ b/src/main/java/RandomRowGeneratorStrategy.java
@@ -0,0 +1,35 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class RandomRowGeneratorStrategy implements RowGeneratorStrategy{
+
+  public static final int FIRST_COLUMN = 0;
+
+  public static Random random = new Random();
+
+  @Override
+  public Row generateRow(int lenOfRow) {
+    return Row.of(lenOfRow, generateNonSequentialRandomLines(lenOfRow));
+  }
+
+  public List<Line> generateNonSequentialRandomLines(int numOfColumn) {
+    List<Line> lines = new ArrayList<>();
+    int nthColumn = FIRST_COLUMN;
+    while (nthColumn < numOfColumn) {
+      nthColumn = addNthColumn(lines, nthColumn);
+    }
+    return lines;
+  }
+
+  private int addNthColumn(List<Line> lines, int nthColumn) {
+    boolean isRow = random.nextBoolean();
+    if (isRow) {
+      lines.add(Line.startWith(nthColumn));
+      nthColumn += 2;
+      return nthColumn;
+    }
+    nthColumn++;
+    return nthColumn;
+  }
+}
diff --git a/src/main/java/Row.java b/src/main/java/Row.java
new file mode 100644
index 0000000..1bbeb36
--- /dev/null
+++ b/src/main/java/Row.java
@@ -0,0 +1,68 @@
+import java.util.List;
+import java.util.Objects;
+
+public class Row {
+
+  public static final String LINE = "-----";
+  public static final String EMPTY_LINE = "     ";
+
+  private int lenOfRow;
+  private List<Line> lines;
+
+  private Row(int lenOfRow, List<Line> lines) {
+    this.lenOfRow = lenOfRow;
+    this.lines = lines;
+  }
+
+  public static Row of(int lenOfRow, List<Line> lines) {
+    return new Row(lenOfRow, lines);
+  }
+
+  public int getNextPosition(int prevPosition) {
+    if (hasLineStartingWith(prevPosition)) {
+      return prevPosition + 1;
+    }
+
+    if (hasLineEndingWith(prevPosition)) {
+      return prevPosition - 1;
+    }
+
+    return prevPosition;
+  }
+
+  public String getLineStartingWith(int position) {
+    if (hasLineStartingWith(position)) {
+      return LINE;
+    }
+    return EMPTY_LINE;
+  }
+
+  public boolean hasLineStartingWith(int prevPosition) {
+    return lines.stream().anyMatch(line -> line.isStartingWith(prevPosition));
+  }
+
+  private boolean hasLineEndingWith(int prevPosition) {
+    return lines.stream().anyMatch(line -> line.isEndingWith(prevPosition));
+  }
+
+  public List<Line> getLines() {
+    return lines;
+  }
+
+  public int getLenOfRow() {
+    return lenOfRow;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    Row row = (Row) o;
+    return Objects.equals(lines, row.lines);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(lines);
+  }
+}
diff --git a/src/main/java/RowGeneratorStrategy.java b/src/main/java/RowGeneratorStrategy.java
new file mode 100644
index 0000000..a9a4ac6
--- /dev/null
+++ b/src/main/java/RowGeneratorStrategy.java
@@ -0,0 +1,3 @@
+public interface RowGeneratorStrategy {
+  Row generateRow(int numOfColumn);
+}
diff --git a/src/main/java/RowWithEvenIndexLinesGeneratorStrategy.java b/src/main/java/RowWithEvenIndexLinesGeneratorStrategy.java
new file mode 100644
index 0000000..fd155e5
--- /dev/null
+++ b/src/main/java/RowWithEvenIndexLinesGeneratorStrategy.java
@@ -0,0 +1,20 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class RowWithEvenIndexLinesGeneratorStrategy implements RowGeneratorStrategy {
+  public List<Line> generateLines(int numOfLines) {
+    List<Line> lines = new ArrayList<>();
+    for (int i=0; i<numOfLines; i++) {
+      if (i % 2 == 0) {
+        Line line = Line.startWith(i);
+        lines.add(line);
+      }
+    }
+    return lines;
+  }
+
+  @Override
+  public Row generateRow(int lenOfRow) {
+    return Row.of(lenOfRow, generateLines(lenOfRow));
+  }
+}
diff --git a/src/main/java/User.java b/src/main/java/User.java
new file mode 100644
index 0000000..c822fc6
--- /dev/null
+++ b/src/main/java/User.java
@@ -0,0 +1,28 @@
+import java.util.Objects;
+
+public class User {
+
+  private final UserName userName;
+  private final int position;
+
+  private User(UserName userName, int position) {
+    this.userName = userName;
+    this.position = position;
+  }
+
+  public static User with(UserName name, int position) {
+    return new User(name, position);
+  }
+
+  public UserName getUserName() {
+    return userName;
+  }
+
+  public int getPosition() {
+    return position;
+  }
+
+  public boolean hasUserName(UserName userName) {
+    return this.userName.equals(userName);
+  }
+}
diff --git a/src/main/java/UserName.java b/src/main/java/UserName.java
new file mode 100644
index 0000000..58077ac
--- /dev/null
+++ b/src/main/java/UserName.java
@@ -0,0 +1,41 @@
+import java.util.Objects;
+
+public class UserName {
+
+  public static final int THRESHOLD = 5;
+  public static final String ERROR_NAME_LENGTH_EXCEEDED = "이름이 5자 넘었습니다.";
+
+  private final String name;
+
+  private UserName(String name) {
+    this.name = name;
+  }
+
+  public static UserName of(String name) {
+    validate(name);
+    return new UserName(name);
+  }
+
+  private static void validate(String name) {
+    if (name.length() > THRESHOLD) {
+      throw new IllegalArgumentException(ERROR_NAME_LENGTH_EXCEEDED);
+    }
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    UserName userName = (UserName) o;
+    return Objects.equals(name, userName.name);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(name);
+  }
+}
diff --git a/src/main/java/empty.txt b/src/main/java/empty.txt
deleted file mode 100644
index e69de29..0000000
diff --git a/src/test/java/ConsoleInputTest.java b/src/test/java/ConsoleInputTest.java
new file mode 100644
index 0000000..1efccd8
--- /dev/null
+++ b/src/test/java/ConsoleInputTest.java
@@ -0,0 +1,60 @@
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ConsoleInputTest {
+  public static List<User> getUsersFixture(String userName) {
+    return ConsoleInput.createUsersFrom(Arrays.asList(userName.split(",")));
+  }
+
+  public static List<Prize> getPrizesFixture(String prizeName) {
+    return ConsoleInput.createPrizesFrom(Arrays.asList(prizeName.split(",")));
+  }
+
+  @Test
+  void createUsers_ValidInput_ValidOutput() {
+    // given
+    List<String> userNames = Arrays.asList("김지우,조광일".split(","));
+    // when
+    List<User> users = ConsoleInput.createUsersFrom(userNames);
+    // then
+    assertThat(users).hasSize(2);
+    assertThat(users.get(0).getUserName().getName()).isEqualTo("김지우");
+    assertThat(users.get(0).getPosition()).isEqualTo(0);
+    assertThat(users.get(1).getUserName().getName()).isEqualTo("조광일");
+    assertThat(users.get(1).getPosition()).isEqualTo(1);
+  }
+
+  @Test
+  void createPrizes_ValidInput_ValidOutput() {
+    // given
+    List<String> prizeNames = Arrays.asList("꽝,3000".split(","));
+    // when
+    List<Prize> prizes = ConsoleInput.createPrizesFrom(prizeNames);
+    // then
+    assertThat(prizes).hasSize(2);
+    assertThat(prizes.get(0).getPrizeName()).isEqualTo("꽝");
+    assertThat(prizes.get(0).getPosition()).isEqualTo(0);
+    assertThat(prizes.get(1).getPrizeName()).isEqualTo("3000");
+    assertThat(prizes.get(1).getPosition()).isEqualTo(1);
+  }
+  
+  @Test
+  void isConvertibleIntoInteger_InputInteger_ReturnTrue() {
+    // given
+    String str = "7";
+    // then
+    assertThat(ConsoleInput.isConvertibleIntoInteger(str)).isTrue();
+  }
+
+  @Test
+  void isConvertibleIntoInteger_InputNotInteger_ReturnFalse() {
+    // given
+    String str = "notConvertible";
+    // then
+    assertThat(ConsoleInput.isConvertibleIntoInteger(str)).isFalse();
+  }
+}
\ No newline at end of file
diff --git a/src/test/java/LadderGameInputDataTest.java b/src/test/java/LadderGameInputDataTest.java
new file mode 100644
index 0000000..6bee7cf
--- /dev/null
+++ b/src/test/java/LadderGameInputDataTest.java
@@ -0,0 +1,47 @@
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class LadderGameInputDataTest {
+  public static LadderGameInputData getLadderInputDataFixture(String userName, int height, String prizeName) {
+    List<User> users = ConsoleInputTest.getUsersFixture(userName);
+    LadderHeight ladderHeight = LadderHeightTest.getLadderHeightFixture(height);
+    List<Prize> prizes = ConsoleInputTest.getPrizesFixture(prizeName);
+    return LadderGameInputData.of(users, ladderHeight, prizes);
+  }
+
+  @Test
+  void of_ValidInput_ValidOutput() {
+    // given
+    List<User> users = new ArrayList<>();
+    users.add(User.with(UserName.of("김지우"),0));
+    users.add(User.with(UserName.of("조광일"),1));
+    LadderHeight height = LadderHeight.of(1);
+    List<Prize> prizes = new ArrayList<>();
+    prizes.add(Prize.with("꽝",0));
+    prizes.add(Prize.with("3000",1));
+    // when
+    LadderGameInputData ladderGameInputData = LadderGameInputData.of(users, height, prizes);
+    // then
+    assertThat(ladderGameInputData.getUsers()).isEqualTo(users);
+    assertThat(ladderGameInputData.getHeight()).isEqualTo(height);
+    assertThat(ladderGameInputData.getPrizes()).isEqualTo(prizes);
+  }
+
+  @Test
+  void of_InvalidInput_ThrowException() {
+    // given
+    List<User> users = new ArrayList<>();
+    users.add(User.with(UserName.of("김지우"),0));
+    LadderHeight height = LadderHeight.of(1);
+    List<Prize> prizes = new ArrayList<>();
+    prizes.add(Prize.with("꽝",0));
+    prizes.add(Prize.with("3000",1));
+    // then
+    assertThatThrownBy(() -> LadderGameInputData.of(users, height, prizes)).isInstanceOf(IllegalArgumentException.class);
+  }
+}
diff --git a/src/test/java/LadderGameTest.java b/src/test/java/LadderGameTest.java
new file mode 100644
index 0000000..a0637c3
--- /dev/null
+++ b/src/test/java/LadderGameTest.java
@@ -0,0 +1,42 @@
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LadderGameTest {
+  @Test
+  void with_ValidInput_ValidOutput() {
+    // given
+    List<User> users = ConsoleInputTest.getUsersFixture("김지우,조광일,구미향");
+    LadderHeight height = LadderHeightTest.getLadderHeightFixture(3);
+    List<Prize> prizes = ConsoleInputTest.getPrizesFixture("꽝,3000,꽝");
+    LadderGameInputData ladderGameInputData = LadderGameInputData.of(users, height, prizes);
+    RowGeneratorStrategy rowGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy();
+    // when
+    LadderGame ladderGame = LadderGame.with(ladderGameInputData, rowGeneratorStrategy);
+    // then
+    assertThat(ladderGame.getUsers()).isEqualTo(users);
+    assertThat(ladderGame.getHeight()).isEqualTo(height);
+    assertThat(ladderGame.getLadderGenerator().getRowGeneratorStrategy()).isEqualTo(rowGeneratorStrategy);
+  }
+
+  @Test
+  void generateLadder_ManualStrategy_ValidLadder() {
+    // given
+    String userNames = "김지우,조광일,구미향";
+    String prizeNames = "꽝,3000,꽝";
+    int numOfNames = 3;
+    int lenOfRow = numOfNames - 1;
+    int height = 4;
+    Row rowFixture = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    LadderGameInputData ladderGameInputData = LadderGameInputDataTest.getLadderInputDataFixture(userNames, height, prizeNames);
+    RowGeneratorStrategy rowGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy();
+    LadderGame ladderGame = LadderGame.with(ladderGameInputData, rowGeneratorStrategy);
+    // when
+    ladderGame.generateLadder();
+    // then
+    assertThat(ladderGame.getLadder().getRows()).hasSize(height);
+    assertThat(ladderGame.getLadder().getRows()).contains(rowFixture);
+  }
+}
diff --git a/src/test/java/LadderGeneratorTest.java b/src/test/java/LadderGeneratorTest.java
new file mode 100644
index 0000000..232f979
--- /dev/null
+++ b/src/test/java/LadderGeneratorTest.java
@@ -0,0 +1,36 @@
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LadderGeneratorTest {
+  @Test
+  void generateLadder_InputManualStrategy() {
+    // given
+    int numOfUsers = 3;
+    int lenOfRow = numOfUsers - 1;
+    int height = 4;
+    LadderGenerator ladderGenerator = LadderGenerator.with(new RowWithEvenIndexLinesGeneratorStrategy());
+    Row RowWithEvenIndexLinesFixture = RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexRowFixture(lenOfRow);
+    // when
+    Ladder ladder = ladderGenerator.generateLadder(numOfUsers, height);
+    // then
+    assertThat(ladder.getRows()).hasSize(height);
+    assertThat(ladder.getRows()).contains(RowWithEvenIndexLinesFixture);
+  }
+
+  @Test
+  void generateRows_InputManualStrategy() {
+    // given
+    int numOfUsers = 3;
+    int numOfEvenIndexLines = numOfUsers / 2;
+    int height = 4;
+    LadderGenerator ladderGenerator = LadderGenerator.with(new RowWithEvenIndexLinesGeneratorStrategy());
+    // when
+    List<Row> rows = ladderGenerator.generateRows(numOfUsers, height);
+    // then
+    assertThat(rows).hasSize(height);
+    assertThat(rows.get(0).getLines()).hasSize(numOfEvenIndexLines);
+  }
+}
diff --git a/src/test/java/LadderHeightTest.java b/src/test/java/LadderHeightTest.java
new file mode 100644
index 0000000..216e478
--- /dev/null
+++ b/src/test/java/LadderHeightTest.java
@@ -0,0 +1,28 @@
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class LadderHeightTest {
+  public static LadderHeight getLadderHeightFixture(int height) {
+    return LadderHeight.of(height);
+  }
+
+  @Test
+  void of_ValidInput_ValidOutput() {
+    // given
+    int height = 1;
+    // when
+    LadderHeight ladderHeight = LadderHeight.of(height);
+    // then
+    assertThat(ladderHeight.getHeight()).isEqualTo(height);
+  }
+
+  @Test
+  void of_InvalidInput_ThrowException() {
+    // given
+    int height = 0;
+    // then
+    assertThatThrownBy(() -> LadderHeight.of(height)).isInstanceOf(IllegalArgumentException.class);
+  }
+}
diff --git a/src/test/java/LadderTest.java b/src/test/java/LadderTest.java
new file mode 100644
index 0000000..bb1ebc1
--- /dev/null
+++ b/src/test/java/LadderTest.java
@@ -0,0 +1,78 @@
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LadderTest {
+  @Test
+  void with_ValidInput_ValidOutput() {
+    // given
+    List<Row> rows = new ArrayList<>();
+    int numOfLines = 3;
+    rows.add(RowTest.getRowFixtureWithLinesStartingWithEvenIndex(numOfLines));
+    rows.add(RowTest.getRowFixtureWithLinesStartingWithEvenIndex(numOfLines));
+    // when
+    Ladder ladder = Ladder.with(rows);
+    // then
+    assertThat(ladder.getRows()).isEqualTo(rows);
+  }
+  
+  @Test
+  void startWith_InputInitialUserPosition_OutputSamePosition() {
+    // given
+    int lenOfRow = 3;
+    List<Row> rows = new ArrayList<>();
+    Row firstRow = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    Row secondRow = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    rows.add(firstRow);
+    rows.add(secondRow);
+    Ladder ladder = Ladder.with(rows);
+    int initialUserPosition = 1;
+    // when
+    int finalPosition = ladder.startWith(initialUserPosition);
+    // then
+    assertThat(finalPosition).isEqualTo(initialUserPosition);
+  }
+
+  @Test
+  void startWith_InputInitialUserPosition_OutputRightPosition() {
+    // given
+    int lenOfRow = 3;
+    List<Row> rows = new ArrayList<>();
+    Row firstRow = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    Row secondRow = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    Row thirdRow = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    rows.add(firstRow);
+    rows.add(secondRow);
+    rows.add(thirdRow);
+    Ladder ladder = Ladder.with(rows);
+    int initialUserPosition = 0;
+    int rightPosition = initialUserPosition + 1;
+    // when
+    int finalPosition = ladder.startWith(initialUserPosition);
+    // then
+    assertThat(finalPosition).isEqualTo(rightPosition);
+  }
+
+  @Test
+  void startWith_InputInitialUserPosition_OutputLeftPosition() {
+    // given
+    int lenOfRow = 3;
+    List<Row> rows = new ArrayList<>();
+    Row firstRow = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    Row secondRow = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    Row thirdRow = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    rows.add(firstRow);
+    rows.add(secondRow);
+    rows.add(thirdRow);
+    Ladder ladder = Ladder.with(rows);
+    int initialUserPosition = 1;
+    int leftPosition = initialUserPosition - 1;
+    // when
+    int finalPosition = ladder.startWith(initialUserPosition);
+    // then
+    assertThat(finalPosition).isEqualTo(leftPosition);
+  }
+}
diff --git a/src/test/java/LineTest.java b/src/test/java/LineTest.java
new file mode 100644
index 0000000..acb569a
--- /dev/null
+++ b/src/test/java/LineTest.java
@@ -0,0 +1,14 @@
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LineTest {
+  @Test
+  void startWith_ValidInput_ValidOutput() {
+    // when
+    Line line = Line.startWith(0);
+    // then
+    assertThat(line.getStartPosition()).isEqualTo(0);
+    assertThat(line.getEndPosition()).isEqualTo(1);
+  }
+}
diff --git a/src/test/java/PrizeTest.java b/src/test/java/PrizeTest.java
new file mode 100644
index 0000000..617eefc
--- /dev/null
+++ b/src/test/java/PrizeTest.java
@@ -0,0 +1,17 @@
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+class PrizeTest {
+  @Test
+  void with_ValidInput_ValidOutput() {
+    // given
+    String prizeName = "testPrizeName";
+    int position = 0;
+    // then
+    assertThat(Prize.with(prizeName, position).getPrizeName()).isEqualTo(prizeName);
+    assertThat(Prize.with(prizeName, position).getPosition()).isEqualTo(position);
+  }
+
+}
\ No newline at end of file
diff --git a/src/test/java/RandomRowGeneratorStrategyTest.java b/src/test/java/RandomRowGeneratorStrategyTest.java
new file mode 100644
index 0000000..9d94eea
--- /dev/null
+++ b/src/test/java/RandomRowGeneratorStrategyTest.java
@@ -0,0 +1,66 @@
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RandomRowGeneratorStrategyTest {
+  @Test
+  void generateLines() {
+    // given
+
+    // when
+
+    // then
+
+  }
+
+  @Test
+  void getNonSequentialRandomLines() {
+    // given
+    RandomRowGeneratorStrategy randomRowGeneratorStrategy = new RandomRowGeneratorStrategy();
+    int numOfLines = 3;
+    // when
+    List<Line> lines = randomRowGeneratorStrategy.generateNonSequentialRandomLines(numOfLines);
+    // then
+    assertThat(isNotSequential(lines)).isTrue();
+  }
+
+  private boolean isNotSequential(List<Line> lines) {
+    int prevEndPosition = -1;
+    for (Line line: lines) {
+      if (line.getStartPosition() == prevEndPosition) {
+        return false;
+      }
+      prevEndPosition = line.getEndPosition();
+    }
+    return true;
+  }
+
+  //  테스트에서만 쓰이는 코드를 위한 테스트
+  @Test
+  void isNotSequential_InputSequentialLines_CheckFalse() {
+    // given
+    List<Line> lines = new ArrayList<>();
+    Line prevSequential = Line.startWith(0);
+    Line nextSequential = Line.startWith(1);
+    lines.add(prevSequential);
+    lines.add(nextSequential);
+    // then
+    assertThat(isNotSequential(lines)).isFalse();
+  }
+
+  //  테스트에서만 쓰이는 코드를 위한 테스트
+  @Test
+  void isNotSequential_InputNotSequentialLines_CheckTrue() {
+    // given
+    List<Line> lines = new ArrayList<>();
+    Line prevSequential = Line.startWith(0);
+    Line nextSequential = Line.startWith(2);
+    lines.add(prevSequential);
+    lines.add(nextSequential);
+    // then
+    assertThat(isNotSequential(lines)).isTrue();
+  }
+}
diff --git a/src/test/java/RowTest.java b/src/test/java/RowTest.java
new file mode 100644
index 0000000..8c4cec8
--- /dev/null
+++ b/src/test/java/RowTest.java
@@ -0,0 +1,64 @@
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RowTest {
+  public static Row getRowFixtureWithLinesStartingWithEvenIndex(int lenOfRow) {
+    return Row.of(lenOfRow, RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexLinesFixture(lenOfRow));
+  }
+
+  @Test
+  void of_ValidInput_ValidOutput() {
+    // given
+    List<Line> lines = new ArrayList<>();
+    lines.add(Line.startWith(0));
+    lines.add(Line.startWith(2));
+    int lenOfRow = 3;
+    // when
+    Row row = Row.of(lenOfRow, lines);
+    // then
+    assertThat(row.getLines()).isEqualTo(lines);
+    assertThat(row.getLenOfRow()).isEqualTo(lenOfRow);
+  }
+
+  @Test
+  void getNextPosition_GivenLeftLine_ThenLeftPosition() {
+    // given
+    int lenOfRow = 2;
+    Row row = getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    int prevPosition = 1;
+    int leftPosition = prevPosition - 1;
+    // when
+    int nextPosition = row.getNextPosition(prevPosition);
+    // then
+    assertThat(nextPosition).isEqualTo(leftPosition);
+  }
+
+  @Test
+  void getNextPosition_GivenRightLine_ThenRightPosition() {
+    // given
+    int lenOfRow = 2;
+    Row row = getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    int prevPosition = 0;
+    int rightPosition = prevPosition + 1;
+    // when
+    int nextPosition = row.getNextPosition(prevPosition);
+    // then
+    assertThat(nextPosition).isEqualTo(rightPosition);
+  }
+
+  @Test
+  void getNextPosition_GivenNoLine_ThenSamePosition() {
+    // given
+    int lenOfRow = 2;
+    Row row = getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow);
+    int prevPosition = 2;
+    // when
+    int nextPosition = row.getNextPosition(prevPosition);
+    // then
+    assertThat(nextPosition).isEqualTo(prevPosition);
+  }
+}
diff --git a/src/test/java/RowWithEvenIndexLinesGeneratorStrategyTest.java b/src/test/java/RowWithEvenIndexLinesGeneratorStrategyTest.java
new file mode 100644
index 0000000..6de60c5
--- /dev/null
+++ b/src/test/java/RowWithEvenIndexLinesGeneratorStrategyTest.java
@@ -0,0 +1,36 @@
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RowWithEvenIndexLinesGeneratorStrategyTest {
+  public static Row getEvenIndexRowFixture(int lenOfRow) {
+    return Row.of(lenOfRow, getEvenIndexLinesFixture(lenOfRow));
+  }
+
+  public static List<Line> getEvenIndexLinesFixture(int numOfLines) {
+    List<Line> lines = new ArrayList<>();
+    for (int i=0; i<numOfLines; i++) {
+      if (i % 2 == 0) {
+        Line line = Line.startWith(i);
+        lines.add(line);
+      }
+    }
+    return lines;
+  }
+
+  @Test
+  void generateLines_InputLineNums_OutputManualLines() {
+    // given
+    RowWithEvenIndexLinesGeneratorStrategy rowWithEvenIndexLinesGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy();
+    int numOfLines = 3;
+    int numOfEvenIndexLines = 3 / 2 + 1;
+    // when
+    List<Line> lines = rowWithEvenIndexLinesGeneratorStrategy.generateLines(numOfLines);
+    // then
+    assertThat(lines).hasSize(numOfEvenIndexLines);
+    assertThat(lines).contains(Line.startWith(0)).contains(Line.startWith(2));
+  }
+}
diff --git a/src/test/java/SampleTest.java b/src/test/java/SampleTest.java
deleted file mode 100644
index fff8f60..0000000
--- a/src/test/java/SampleTest.java
+++ /dev/null
@@ -1,14 +0,0 @@
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class SampleTest {
-    @Test
-    void a_few_simple_assertions() {
-        assertThat("The Lord of the Rings")
-                .isNotNull()
-                .startsWith("The")
-                .contains("Lord")
-                .endsWith("Rings");
-    }
-}
\ No newline at end of file
diff --git a/src/test/java/UserNameTest.java b/src/test/java/UserNameTest.java
new file mode 100644
index 0000000..a75754e
--- /dev/null
+++ b/src/test/java/UserNameTest.java
@@ -0,0 +1,24 @@
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class UserNameTest {
+  @Test
+  void of_ValidInput_ValidOutput() {
+    // given
+    String name = "김지우";
+    // when
+    UserName userName = UserName.of(name);
+    // then
+    assertThat(userName.getName()).isEqualTo(name);
+  }
+
+  @Test
+  void of_InvalidInput_InvalidOutput() {
+    // given
+    String name = "이름길이초과";
+    // then
+    assertThatThrownBy(() -> UserName.of(name)).isInstanceOf(IllegalArgumentException.class);
+  }
+}
diff --git a/src/test/java/UserTest.java b/src/test/java/UserTest.java
new file mode 100644
index 0000000..cf17718
--- /dev/null
+++ b/src/test/java/UserTest.java
@@ -0,0 +1,35 @@
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class UserTest {
+  @Test
+  void with_ValidInput_ValidOutput() {
+    // given
+    UserName name = UserName.of("김지우");
+    int position = 1;
+    // when
+    User user = User.with(name, position);
+    // then
+    assertThat(user.getUserName()).isEqualTo(name);
+    assertThat(user.getPosition()).isEqualTo(position);
+  }
+
+  @Test
+  void hasUserName_SameName_ReturnTrue() {
+    // given
+    User user = User.with(UserName.of("same"), 0);
+    UserName userName = UserName.of("same");
+    // then
+    assertThat(user.hasUserName(userName)).isTrue();
+  }
+
+  @Test
+  void hasUserName_DifferentName_ReturnFalse() {
+    // given
+    User user = User.with(UserName.of("Diff"), 0);
+    UserName userName = UserName.of("diff");
+    // then
+    assertThat(user.hasUserName(userName)).isFalse();
+  }
+}