From 1e8dfa4777c633a039e08dd500a58044f0832bbc Mon Sep 17 00:00:00 2001 From: deocksoo Date: Sat, 11 Jan 2020 09:04:53 +0900 Subject: [PATCH 01/12] Update .gitignore --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 492f742..bf433ff 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ .idea/** .gradle/** -build/ +build/** +out/** From f7e611c1a093249471165e27991e3dba10010f56 Mon Sep 17 00:00:00 2001 From: "Jiwoo,Kim" Date: Mon, 13 Jan 2020 15:49:16 +0900 Subject: [PATCH 02/12] Add feat list to README.md --- README.md | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/README.md b/README.md index 42fb362..bbdaebb 100644 --- a/README.md +++ b/README.md @@ -1 +1,24 @@ # java-ladder 게임 + +## 기능 목록 + +- 사용자로부터 입력 받기 + + - 이름은 쉼표를 기준으로 한다. + + - 이름은 최대 5글자까지 + + - 최대 사다리 높이를 받아야 한다. + + - 높이는 1이상 + +- 사다리 만들기 + + - 이름 길이에 따라 사다리 폭이 달라져야 한다. + + - 사다리 라인이 겹치지 않도록 해야한다. + + + - 사다리 출력하기 + + - 사용자 이름과 사다리를 함께 출력해야한다. \ No newline at end of file From 5074fd94d5f1ef2bbf9a2e81d18d545ca8261cfc Mon Sep 17 00:00:00 2001 From: "Jiwoo,Kim" Date: Wed, 15 Jan 2020 11:18:44 +0900 Subject: [PATCH 03/12] feat : get console input from user - add ConsoleInput.java - add LadderInputData.java - add User.java - add LadderHeight.java --- src/main/java/Application.java | 5 +++ src/main/java/ConsoleInput.java | 46 ++++++++++++++++++++++++++ src/main/java/LadderHeight.java | 26 +++++++++++++++ src/main/java/LadderInputData.java | 24 ++++++++++++++ src/main/java/User.java | 22 ++++++++++++ src/main/java/UserName.java | 26 +++++++++++++++ src/main/java/empty.txt | 0 src/test/java/ConsoleInputTest.java | 22 ++++++++++++ src/test/java/LadderHeightTest.java | 24 ++++++++++++++ src/test/java/LadderInputDataTest.java | 22 ++++++++++++ src/test/java/SampleTest.java | 14 -------- src/test/java/UserNameTest.java | 24 ++++++++++++++ src/test/java/UserTest.java | 17 ++++++++++ 13 files changed, 258 insertions(+), 14 deletions(-) create mode 100644 src/main/java/Application.java create mode 100644 src/main/java/ConsoleInput.java create mode 100644 src/main/java/LadderHeight.java create mode 100644 src/main/java/LadderInputData.java create mode 100644 src/main/java/User.java create mode 100644 src/main/java/UserName.java delete mode 100644 src/main/java/empty.txt create mode 100644 src/test/java/ConsoleInputTest.java create mode 100644 src/test/java/LadderHeightTest.java create mode 100644 src/test/java/LadderInputDataTest.java delete mode 100644 src/test/java/SampleTest.java create mode 100644 src/test/java/UserNameTest.java create mode 100644 src/test/java/UserTest.java diff --git a/src/main/java/Application.java b/src/main/java/Application.java new file mode 100644 index 0000000..f135b05 --- /dev/null +++ b/src/main/java/Application.java @@ -0,0 +1,5 @@ +public class Application { + public static void main(String[] args) { + LadderInputData ladderInputData = ConsoleInput.getLadderData(); + } +} diff --git a/src/main/java/ConsoleInput.java b/src/main/java/ConsoleInput.java new file mode 100644 index 0000000..a46d933 --- /dev/null +++ b/src/main/java/ConsoleInput.java @@ -0,0 +1,46 @@ +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 Scanner sc = new Scanner(System.in); + + public static LadderInputData getLadderData() { + List users = getUsers(getInputUserNames()); + LadderHeight height = getHeight(); + return LadderInputData.of(users, height); + } + + static List getUsers(List userNames) { + List 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 List getInputUserNames() { + System.out.println(MESSAGE_INPUT_USER_NAMES); + return Arrays.asList(sc.nextLine().split(DELIMITER)); + } + + private static LadderHeight getHeight() { + System.out.println(MESSAGE_INPUT_MAX_LADDER_HEIGHT); + return LadderHeight.of(getInputHeight()); + } + + private static int getInputHeight() { + return sc.nextInt(); + } +} 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/LadderInputData.java b/src/main/java/LadderInputData.java new file mode 100644 index 0000000..08b2563 --- /dev/null +++ b/src/main/java/LadderInputData.java @@ -0,0 +1,24 @@ +import java.util.List; + +public class LadderInputData { + + private List users; + private LadderHeight height; + + private LadderInputData(List users, LadderHeight height) { + this.users = users; + this.height = height; + } + + public static LadderInputData of(List users, LadderHeight height) { + return new LadderInputData(users, height); + } + + public List getUsers() { + return users; + } + + public LadderHeight getHeight() { + return height; + } +} diff --git a/src/main/java/User.java b/src/main/java/User.java new file mode 100644 index 0000000..9eeb945 --- /dev/null +++ b/src/main/java/User.java @@ -0,0 +1,22 @@ +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; + } +} diff --git a/src/main/java/UserName.java b/src/main/java/UserName.java new file mode 100644 index 0000000..fbdca40 --- /dev/null +++ b/src/main/java/UserName.java @@ -0,0 +1,26 @@ +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; + } +} 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..21d99cb --- /dev/null +++ b/src/test/java/ConsoleInputTest.java @@ -0,0 +1,22 @@ +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +class ConsoleInputTest { + @Test + void getUsers_ValidInput_ValidOutput() { + // given + List userNames = Arrays.asList("김지우,조광일".split(",")); + // when + List users = ConsoleInput.getUsers(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); + } +} \ No newline at end of file diff --git a/src/test/java/LadderHeightTest.java b/src/test/java/LadderHeightTest.java new file mode 100644 index 0000000..d9d83df --- /dev/null +++ b/src/test/java/LadderHeightTest.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 LadderHeightTest { + @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/LadderInputDataTest.java b/src/test/java/LadderInputDataTest.java new file mode 100644 index 0000000..93f182c --- /dev/null +++ b/src/test/java/LadderInputDataTest.java @@ -0,0 +1,22 @@ +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class LadderInputDataTest { + @Test + void of_ValidInput_ValidOutput() { + // given + List users = new ArrayList<>(); + users.add(User.with(UserName.of("김지우"),0)); + users.add(User.with(UserName.of("조광일"),1)); + LadderHeight height = LadderHeight.of(1); + // when + LadderInputData ladderInputData = LadderInputData.of(users, height); + // then + assertThat(ladderInputData.getUsers()).isEqualTo(users); + assertThat(ladderInputData.getHeight()).isEqualTo(height); + } +} 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..36d2878 --- /dev/null +++ b/src/test/java/UserTest.java @@ -0,0 +1,17 @@ +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); + } +} From 15dc27ed1224ca4d1d275ac80789883378db3f7e Mon Sep 17 00:00:00 2001 From: "Jiwoo,Kim" Date: Wed, 15 Jan 2020 11:23:54 +0900 Subject: [PATCH 04/12] Modify README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index bbdaebb..734d4ae 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ - 사다리 만들기 - - 이름 길이에 따라 사다리 폭이 달라져야 한다. + - 이름 길이 5 기준으로 사다리 폭이 정해진다. - 사다리 라인이 겹치지 않도록 해야한다. From 932388526c01b65a7d2d5de30c6afebc78148014 Mon Sep 17 00:00:00 2001 From: "Jiwoo,Kim" Date: Thu, 16 Jan 2020 13:33:16 +0900 Subject: [PATCH 05/12] Add Row generate Strategy - add a strategy for random row - add a strategy for manual row having even index lines --- src/main/java/RandomRowGeneratorStrategy.java | 37 +++++++++++ src/main/java/RowGeneratorStrategy.java | 3 + ...owWithEvenIndexLinesGeneratorStrategy.java | 20 ++++++ .../java/RandomRowGeneratorStrategyTest.java | 66 +++++++++++++++++++ ...thEvenIndexLinesGeneratorStrategyTest.java | 36 ++++++++++ 5 files changed, 162 insertions(+) create mode 100644 src/main/java/RandomRowGeneratorStrategy.java create mode 100644 src/main/java/RowGeneratorStrategy.java create mode 100644 src/main/java/RowWithEvenIndexLinesGeneratorStrategy.java create mode 100644 src/test/java/RandomRowGeneratorStrategyTest.java create mode 100644 src/test/java/RowWithEvenIndexLinesGeneratorStrategyTest.java diff --git a/src/main/java/RandomRowGeneratorStrategy.java b/src/main/java/RandomRowGeneratorStrategy.java new file mode 100644 index 0000000..f969f47 --- /dev/null +++ b/src/main/java/RandomRowGeneratorStrategy.java @@ -0,0 +1,37 @@ +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 numOfColumn) { + return Row.of(generateNonSequentialRandomLines(numOfColumn)); + } + + public List generateNonSequentialRandomLines(int numOfColumn) { + List lines = new ArrayList<>(); + + int nthColumn = FIRST_COLUMN; + while (nthColumn < numOfColumn) { + nthColumn = addNthColumn(lines, nthColumn); + } + + return lines; + } + + private int addNthColumn(List 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/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..ab11479 --- /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 generateLines(int numOfLines) { + List lines = new ArrayList<>(); + for (int i=0; i lines = randomRowGeneratorStrategy.generateNonSequentialRandomLines(numOfLines); + // then + assertThat(isNotSequential(lines)).isTrue(); + } + + private boolean isNotSequential(List 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 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 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/RowWithEvenIndexLinesGeneratorStrategyTest.java b/src/test/java/RowWithEvenIndexLinesGeneratorStrategyTest.java new file mode 100644 index 0000000..73d4fe9 --- /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 numOfLines) { + return Row.of(getEvenIndexLinesFixture(numOfLines)); + } + + public static List getEvenIndexLinesFixture(int numOfLines) { + List lines = new ArrayList<>(); + for (int i=0; i lines = rowWithEvenIndexLinesGeneratorStrategy.generateLines(numOfLines); + // then + assertThat(lines).hasSize(numOfEvenIndexLines); + assertThat(lines).contains(Line.startWith(0)).contains(Line.startWith(2)); + } +} From edecdcef02085a56cec9072b93a6c66aa45f571a Mon Sep 17 00:00:00 2001 From: "Jiwoo,Kim" Date: Thu, 16 Jan 2020 13:37:20 +0900 Subject: [PATCH 06/12] add fixtures for test --- src/main/java/Application.java | 2 ++ src/test/java/ConsoleInputTest.java | 4 ++++ src/test/java/LadderHeightTest.java | 4 ++++ src/test/java/LadderInputDataTest.java | 6 ++++++ 4 files changed, 16 insertions(+) diff --git a/src/main/java/Application.java b/src/main/java/Application.java index f135b05..54c2d44 100644 --- a/src/main/java/Application.java +++ b/src/main/java/Application.java @@ -1,5 +1,7 @@ public class Application { public static void main(String[] args) { LadderInputData ladderInputData = ConsoleInput.getLadderData(); + LadderGame ladderGame = LadderGame.with(ladderInputData, new RandomRowGeneratorStrategy()); + ladderGame.generateLadder(); } } diff --git a/src/test/java/ConsoleInputTest.java b/src/test/java/ConsoleInputTest.java index 21d99cb..5b7a663 100644 --- a/src/test/java/ConsoleInputTest.java +++ b/src/test/java/ConsoleInputTest.java @@ -6,6 +6,10 @@ import static org.assertj.core.api.Assertions.assertThat; class ConsoleInputTest { + public static List getUsersFixture(String name) { + return ConsoleInput.getUsers(Arrays.asList(name.split(","))); + } + @Test void getUsers_ValidInput_ValidOutput() { // given diff --git a/src/test/java/LadderHeightTest.java b/src/test/java/LadderHeightTest.java index d9d83df..216e478 100644 --- a/src/test/java/LadderHeightTest.java +++ b/src/test/java/LadderHeightTest.java @@ -4,6 +4,10 @@ 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 diff --git a/src/test/java/LadderInputDataTest.java b/src/test/java/LadderInputDataTest.java index 93f182c..35ade2c 100644 --- a/src/test/java/LadderInputDataTest.java +++ b/src/test/java/LadderInputDataTest.java @@ -6,6 +6,12 @@ import static org.assertj.core.api.Assertions.assertThat; public class LadderInputDataTest { + public static LadderInputData getLadderInputDataFixture(String name, int height) { + List users = ConsoleInputTest.getUsersFixture(name); + LadderHeight ladderHeight = LadderHeightTest.getLadderHeightFixture(height); + return LadderInputData.of(users, ladderHeight); + } + @Test void of_ValidInput_ValidOutput() { // given From 11bb627980942f0961b3f5928f34d9bd26f6e4ca Mon Sep 17 00:00:00 2001 From: "Jiwoo,Kim" Date: Thu, 16 Jan 2020 13:37:30 +0900 Subject: [PATCH 07/12] Add Ladder - add Ladder.java - add Row.java - add Line.java - add LadderGenerator.java --- src/main/java/Ladder.java | 19 ++++++++++++ src/main/java/LadderGame.java | 42 ++++++++++++++++++++++++++ src/main/java/LadderGenerator.java | 32 ++++++++++++++++++++ src/main/java/Line.java | 38 +++++++++++++++++++++++ src/main/java/Row.java | 32 ++++++++++++++++++++ src/test/java/LadderGameTest.java | 39 ++++++++++++++++++++++++ src/test/java/LadderGeneratorTest.java | 35 +++++++++++++++++++++ src/test/java/LadderTest.java | 21 +++++++++++++ src/test/java/LineTest.java | 14 +++++++++ src/test/java/RowTest.java | 24 +++++++++++++++ 10 files changed, 296 insertions(+) create mode 100644 src/main/java/Ladder.java create mode 100644 src/main/java/LadderGame.java create mode 100644 src/main/java/LadderGenerator.java create mode 100644 src/main/java/Line.java create mode 100644 src/main/java/Row.java create mode 100644 src/test/java/LadderGameTest.java create mode 100644 src/test/java/LadderGeneratorTest.java create mode 100644 src/test/java/LadderTest.java create mode 100644 src/test/java/LineTest.java create mode 100644 src/test/java/RowTest.java diff --git a/src/main/java/Ladder.java b/src/main/java/Ladder.java new file mode 100644 index 0000000..9bf1cdd --- /dev/null +++ b/src/main/java/Ladder.java @@ -0,0 +1,19 @@ +import java.util.ArrayList; +import java.util.List; + +public class Ladder { + + private List rows; + + private Ladder(List rows) { + this.rows = rows; + } + + public static Ladder with(List rows) { + return new Ladder(rows); + } + + public List getRows() { + return rows; + } +} diff --git a/src/main/java/LadderGame.java b/src/main/java/LadderGame.java new file mode 100644 index 0000000..81125b0 --- /dev/null +++ b/src/main/java/LadderGame.java @@ -0,0 +1,42 @@ +import java.util.List; + +public class LadderGame { + + private List users; + private LadderHeight height; + private LadderGenerator ladderGenerator; + private Ladder ladder; + + private LadderGame(LadderInputData ladderInputData, RowGeneratorStrategy rowGeneratorStrategy) { + this.users = ladderInputData.getUsers(); + this.height = ladderInputData.getHeight(); +// TODO 생성자에서 데이터를 넣어주느냐 vs 메서드 파라미터로 넣어주느냐 ( 각각 어떤 변화들을 야기하는가?!) +// TODO 파라미터로 넣어주면 generateRows에 자유도가 생김. + this.ladderGenerator = new LadderGenerator(rowGeneratorStrategy); + } + + public static LadderGame with(LadderInputData ladderInputData, RowGeneratorStrategy rowGeneratorStrategy) { + return new LadderGame(ladderInputData, rowGeneratorStrategy); + } + + public void generateLadder() { + int numOfColumn = users.size(); + ladder = ladderGenerator.generateLadder(numOfColumn, height.getHeight()); + } + + public List getUsers() { + return users; + } + + public LadderHeight getHeight() { + return height; + } + + public LadderGenerator getLadderGenerator() { + return ladderGenerator; + } + + public Ladder getLadder() { + return ladder; + } +} diff --git a/src/main/java/LadderGenerator.java b/src/main/java/LadderGenerator.java new file mode 100644 index 0000000..019ba33 --- /dev/null +++ b/src/main/java/LadderGenerator.java @@ -0,0 +1,32 @@ +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 generateRows(int numOfColumn, int height) { + List rows = new ArrayList<>(); + for (int i=0; i lines; + + private Row(List lines) { + this.lines = lines; + } + + public static Row of(List lines) { + return new Row(lines); + } + + public List getLines() { + return lines; + } + + @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/test/java/LadderGameTest.java b/src/test/java/LadderGameTest.java new file mode 100644 index 0000000..88a6beb --- /dev/null +++ b/src/test/java/LadderGameTest.java @@ -0,0 +1,39 @@ +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 users = ConsoleInputTest.getUsersFixture("김지우,조광일,구미향"); + LadderHeight height = LadderHeightTest.getLadderHeightFixture(3); + LadderInputData ladderInputData = LadderInputData.of(users, height); + RowGeneratorStrategy rowGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy(); + // when + LadderGame ladderGame = LadderGame.with(ladderInputData, 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 names = "김지우,조광일,구미향"; + int numOfNames = 3; + int height = 4; + Row rowFixture = RowTest.getRowFixture(numOfNames); + LadderInputData ladderInputData = LadderInputDataTest.getLadderInputDataFixture(names, height); + RowGeneratorStrategy rowGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy(); + LadderGame ladderGame = LadderGame.with(ladderInputData, rowGeneratorStrategy); + // when + ladderGame.generateLadder(); + // then 테스트 코드들을 관통하는 Fixture + 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..248eed0 --- /dev/null +++ b/src/test/java/LadderGeneratorTest.java @@ -0,0 +1,35 @@ +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 numOfColumn = 3; + int height = 4; + LadderGenerator ladderGenerator = LadderGenerator.with(new RowWithEvenIndexLinesGeneratorStrategy()); + Row RowWithEvenIndexLinesFixture = RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexRowFixture(numOfColumn); + // when + Ladder ladder = ladderGenerator.generateLadder(numOfColumn, height); + // then + assertThat(ladder.getRows()).hasSize(height); + assertThat(ladder.getRows()).contains(RowWithEvenIndexLinesFixture); + } + + @Test + void generateRows_InputManualStrategy() { + // given + int numOfColumn = 3; + int numOfEvenIndexLines = numOfColumn / 2 + 1; + int height = 4; + LadderGenerator ladderGenerator = LadderGenerator.with(new RowWithEvenIndexLinesGeneratorStrategy()); + // when + List rows = ladderGenerator.generateRows(numOfColumn, height); + // then + assertThat(rows).hasSize(height); + assertThat(rows.get(0).getLines()).hasSize(numOfEvenIndexLines); + } +} diff --git a/src/test/java/LadderTest.java b/src/test/java/LadderTest.java new file mode 100644 index 0000000..0d49699 --- /dev/null +++ b/src/test/java/LadderTest.java @@ -0,0 +1,21 @@ +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 rows = new ArrayList<>(); + int numOfLines = 3; + rows.add(RowTest.getRowFixture(numOfLines)); + rows.add(RowTest.getRowFixture(numOfLines)); + // when + Ladder ladder = Ladder.with(rows); + // then + assertThat(ladder.getRows()).isEqualTo(rows); + } +} 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/RowTest.java b/src/test/java/RowTest.java new file mode 100644 index 0000000..02b4eaf --- /dev/null +++ b/src/test/java/RowTest.java @@ -0,0 +1,24 @@ +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 getRowFixture(int numOfLines) { + return Row.of(RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexLinesFixture(numOfLines)); + } + + @Test + void of_ValidInput_ValidOutput() { + // given + List lines = new ArrayList<>(); + lines.add(Line.startWith(0)); + lines.add(Line.startWith(2)); + // when + Row row = Row.of(lines); + // then + assertThat(row.getLines()).isEqualTo(lines); + } +} From 53dbd5fa1d30660ebd19fd78f4c39fbd4e36919a Mon Sep 17 00:00:00 2001 From: "Jiwoo,Kim" Date: Fri, 17 Jan 2020 14:46:15 +0900 Subject: [PATCH 08/12] feat : show laddergame - show users - show ladder --- src/main/java/Application.java | 1 + src/main/java/Ladder.java | 5 ++- src/main/java/LadderGame.java | 24 +++++++++++ src/main/java/LadderGenerator.java | 7 ++-- src/main/java/Line.java | 4 ++ src/main/java/RandomRowGeneratorStrategy.java | 6 +-- src/main/java/Row.java | 40 +++++++++++++++++-- ...owWithEvenIndexLinesGeneratorStrategy.java | 4 +- src/main/java/User.java | 4 ++ src/main/java/UserName.java | 11 +++++ src/test/java/LadderGeneratorTest.java | 12 +++--- src/test/java/RowTest.java | 8 ++-- ...thEvenIndexLinesGeneratorStrategyTest.java | 4 +- 13 files changed, 106 insertions(+), 24 deletions(-) diff --git a/src/main/java/Application.java b/src/main/java/Application.java index 54c2d44..2e45136 100644 --- a/src/main/java/Application.java +++ b/src/main/java/Application.java @@ -3,5 +3,6 @@ public static void main(String[] args) { LadderInputData ladderInputData = ConsoleInput.getLadderData(); LadderGame ladderGame = LadderGame.with(ladderInputData, new RandomRowGeneratorStrategy()); ladderGame.generateLadder(); + ladderGame.showLadderGame(); } } diff --git a/src/main/java/Ladder.java b/src/main/java/Ladder.java index 9bf1cdd..be55657 100644 --- a/src/main/java/Ladder.java +++ b/src/main/java/Ladder.java @@ -1,4 +1,3 @@ -import java.util.ArrayList; import java.util.List; public class Ladder { @@ -16,4 +15,8 @@ public static Ladder with(List rows) { public List getRows() { return rows; } + + public void show() { + rows.forEach(Row::show); + } } diff --git a/src/main/java/LadderGame.java b/src/main/java/LadderGame.java index 81125b0..3ed2222 100644 --- a/src/main/java/LadderGame.java +++ b/src/main/java/LadderGame.java @@ -2,6 +2,9 @@ public class LadderGame { + public static final String BLANK_BETWEEN_NAMES = " "; + public static final String NEXT = "\n"; + private List users; private LadderHeight height; private LadderGenerator ladderGenerator; @@ -39,4 +42,25 @@ public LadderGenerator getLadderGenerator() { public Ladder getLadder() { return ladder; } + + public void showLadderGame() { + showUsers(); + showLadder(); + } + + private void showUsers() { + for (User user: users) { + user.showUserName(); + System.out.print(BLANK_BETWEEN_NAMES); + } + moveToNextRow(); + } + + private void moveToNextRow() { + System.out.print(NEXT); + } + + private void showLadder() { + ladder.show(); + } } diff --git a/src/main/java/LadderGenerator.java b/src/main/java/LadderGenerator.java index 019ba33..b089581 100644 --- a/src/main/java/LadderGenerator.java +++ b/src/main/java/LadderGenerator.java @@ -15,15 +15,16 @@ public static LadderGenerator with(RowGeneratorStrategy rowGeneratorStrategy) { public List generateRows(int numOfColumn, int height) { List rows = new ArrayList<>(); + int lenOfRow = numOfColumn - 1; for (int i=0; i generateNonSequentialRandomLines(int numOfColumn) { List lines = new ArrayList<>(); - int nthColumn = FIRST_COLUMN; while (nthColumn < numOfColumn) { nthColumn = addNthColumn(lines, nthColumn); } - return lines; } diff --git a/src/main/java/Row.java b/src/main/java/Row.java index 757ae20..c1b85d4 100644 --- a/src/main/java/Row.java +++ b/src/main/java/Row.java @@ -3,20 +3,54 @@ public class Row { + public static final String ROW_BAR = "|"; + public static final String LINE = "-----"; + public static final String BLANK_SPACE_BETWEEN_BARS = " "; + public static final String HEAD_OF_ROW = " "; + + private int lenOfRow; private List lines; - private Row(List lines) { + private Row(int lenOfRow, List lines) { + this.lenOfRow = lenOfRow; this.lines = lines; } - public static Row of(List lines) { - return new Row(lines); + public static Row of(int lenOfRow, List lines) { + return new Row(lenOfRow, lines); + } + + public void show() { + String row = rowToString(); + System.out.print(HEAD_OF_ROW); + System.out.println(row); + } + + private String rowToString() { + String row = ""; + for (int position=0; position line.isStartingWith(point)); + if (isLineStartingWithPointExist) { + return LINE; + } + return BLANK_SPACE_BETWEEN_BARS; } public List getLines() { return lines; } + public int getLenOfRow() { + return lenOfRow; + } + @Override public boolean equals(Object o) { if (this == o) return true; diff --git a/src/main/java/RowWithEvenIndexLinesGeneratorStrategy.java b/src/main/java/RowWithEvenIndexLinesGeneratorStrategy.java index ab11479..fd155e5 100644 --- a/src/main/java/RowWithEvenIndexLinesGeneratorStrategy.java +++ b/src/main/java/RowWithEvenIndexLinesGeneratorStrategy.java @@ -14,7 +14,7 @@ public List generateLines(int numOfLines) { } @Override - public Row generateRow(int numOfColumn) { - return Row.of(generateLines(numOfColumn)); + 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 index 9eeb945..ee47dc4 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -19,4 +19,8 @@ public UserName getUserName() { public int getPosition() { return position; } + + public void showUserName() { + userName.show(); + } } diff --git a/src/main/java/UserName.java b/src/main/java/UserName.java index fbdca40..5416304 100644 --- a/src/main/java/UserName.java +++ b/src/main/java/UserName.java @@ -2,6 +2,8 @@ public class UserName { public static final int THRESHOLD = 5; public static final String ERROR_NAME_LENGTH_EXCEEDED = "이름이 5자 넘었습니다."; + public static final String BLANK_SPACE = " "; + public static final String NULL = "\0"; private final String name; @@ -23,4 +25,13 @@ private static void validate(String name) { public String getName() { return name; } + + public void show() { + int blankSpaceNums = 5 - name.length(); + System.out.print(getBlankSpace(blankSpaceNums) + name); + } + + private String getBlankSpace(int blankSpaceNums) { + return new String(new char[blankSpaceNums]).replace(NULL, BLANK_SPACE); + } } diff --git a/src/test/java/LadderGeneratorTest.java b/src/test/java/LadderGeneratorTest.java index 248eed0..4e16959 100644 --- a/src/test/java/LadderGeneratorTest.java +++ b/src/test/java/LadderGeneratorTest.java @@ -8,12 +8,12 @@ public class LadderGeneratorTest { @Test void generateLadder_InputManualStrategy() { // given - int numOfColumn = 3; + int numOfGenerableColumn = 3; int height = 4; LadderGenerator ladderGenerator = LadderGenerator.with(new RowWithEvenIndexLinesGeneratorStrategy()); - Row RowWithEvenIndexLinesFixture = RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexRowFixture(numOfColumn); + Row RowWithEvenIndexLinesFixture = RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexRowFixture(numOfGenerableColumn); // when - Ladder ladder = ladderGenerator.generateLadder(numOfColumn, height); + Ladder ladder = ladderGenerator.generateLadder(numOfGenerableColumn, height); // then assertThat(ladder.getRows()).hasSize(height); assertThat(ladder.getRows()).contains(RowWithEvenIndexLinesFixture); @@ -22,12 +22,12 @@ void generateLadder_InputManualStrategy() { @Test void generateRows_InputManualStrategy() { // given - int numOfColumn = 3; - int numOfEvenIndexLines = numOfColumn / 2 + 1; + int numOfGenerableColumn = 3; + int numOfEvenIndexLines = numOfGenerableColumn / 2 + 1; int height = 4; LadderGenerator ladderGenerator = LadderGenerator.with(new RowWithEvenIndexLinesGeneratorStrategy()); // when - List rows = ladderGenerator.generateRows(numOfColumn, height); + List rows = ladderGenerator.generateRows(numOfGenerableColumn, height); // then assertThat(rows).hasSize(height); assertThat(rows.get(0).getLines()).hasSize(numOfEvenIndexLines); diff --git a/src/test/java/RowTest.java b/src/test/java/RowTest.java index 02b4eaf..18e657e 100644 --- a/src/test/java/RowTest.java +++ b/src/test/java/RowTest.java @@ -6,8 +6,8 @@ import static org.assertj.core.api.Assertions.assertThat; public class RowTest { - public static Row getRowFixture(int numOfLines) { - return Row.of(RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexLinesFixture(numOfLines)); + public static Row getRowFixture(int lenOfRow) { + return Row.of(lenOfRow, RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexLinesFixture(lenOfRow)); } @Test @@ -16,9 +16,11 @@ void of_ValidInput_ValidOutput() { List lines = new ArrayList<>(); lines.add(Line.startWith(0)); lines.add(Line.startWith(2)); + int lenOfRow = 3; // when - Row row = Row.of(lines); + Row row = Row.of(lenOfRow, lines); // then assertThat(row.getLines()).isEqualTo(lines); + assertThat(row.getLenOfRow()).isEqualTo(lenOfRow); } } diff --git a/src/test/java/RowWithEvenIndexLinesGeneratorStrategyTest.java b/src/test/java/RowWithEvenIndexLinesGeneratorStrategyTest.java index 73d4fe9..6de60c5 100644 --- a/src/test/java/RowWithEvenIndexLinesGeneratorStrategyTest.java +++ b/src/test/java/RowWithEvenIndexLinesGeneratorStrategyTest.java @@ -6,8 +6,8 @@ import static org.assertj.core.api.Assertions.assertThat; public class RowWithEvenIndexLinesGeneratorStrategyTest { - public static Row getEvenIndexRowFixture(int numOfLines) { - return Row.of(getEvenIndexLinesFixture(numOfLines)); + public static Row getEvenIndexRowFixture(int lenOfRow) { + return Row.of(lenOfRow, getEvenIndexLinesFixture(lenOfRow)); } public static List getEvenIndexLinesFixture(int numOfLines) { From 0b400501ce859c10d2c7838df1e8ab9925f27425 Mon Sep 17 00:00:00 2001 From: jiwoo Date: Tue, 28 Jan 2020 16:01:16 +0900 Subject: [PATCH 09/12] feat : input ladder prize - add Prize.java - add field 'prizes' in LadderInputData.java - add a method that validate whether num of users is equal to num of prizes --- README.md | 8 ++++-- src/main/java/ConsoleInput.java | 39 +++++++++++++++++++------- src/main/java/LadderGenerator.java | 4 +-- src/main/java/LadderInputData.java | 21 ++++++++++++-- src/main/java/Prize.java | 22 +++++++++++++++ src/test/java/ConsoleInputTest.java | 26 ++++++++++++++--- src/test/java/LadderGameTest.java | 13 +++++---- src/test/java/LadderGeneratorTest.java | 13 +++++---- src/test/java/LadderInputDataTest.java | 27 +++++++++++++++--- src/test/java/PrizeTest.java | 17 +++++++++++ 10 files changed, 154 insertions(+), 36 deletions(-) create mode 100644 src/main/java/Prize.java create mode 100644 src/test/java/PrizeTest.java diff --git a/README.md b/README.md index 734d4ae..f21ff34 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,10 @@ - 최대 사다리 높이를 받아야 한다. - 높이는 1이상 + + - 사다리 상품을 입력 받는다. + + - 입력 받은 상품의 수와 이름의 수가 같아야 한다. (에러 팡) - 사다리 만들기 @@ -19,6 +23,6 @@ - 사다리 라인이 겹치지 않도록 해야한다. - - 사다리 출력하기 +- 사다리 출력하기 - - 사용자 이름과 사다리를 함께 출력해야한다. \ No newline at end of file + - 사용자 이름과 사다리를 함께 출력해야한다. diff --git a/src/main/java/ConsoleInput.java b/src/main/java/ConsoleInput.java index a46d933..e192c73 100644 --- a/src/main/java/ConsoleInput.java +++ b/src/main/java/ConsoleInput.java @@ -9,25 +9,32 @@ public class ConsoleInput { 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 Scanner sc = new Scanner(System.in); public static LadderInputData getLadderData() { - List users = getUsers(getInputUserNames()); - LadderHeight height = getHeight(); - return LadderInputData.of(users, height); + List users = createUsersFrom(getInputUserNames()); + LadderHeight height = createHeight(); + List prizes = createPrizesFrom(getInputPrizeNames()); + return LadderInputData.of(users, height, prizes); } - static List getUsers(List userNames) { - List users = new ArrayList<>(); + private static List getInputPrizeNames() { + System.out.println(MESSAGE_INPUT_GAME_PRIZES); + return Arrays.asList(sc.nextLine().split(DELIMITER)); + } + + static List createPrizesFrom(List prizeNames) { + List prizes = new ArrayList<>(); int position = INITIAL_POSITION; - for (String userName: userNames) { - User user = User.with(UserName.of(userName), position); - users.add(user); + for (String prizeName: prizeNames) { + Prize prize = Prize.with(prizeName, position); + prizes.add(prize); position++; } - return users; + return prizes; } private static List getInputUserNames() { @@ -35,7 +42,19 @@ private static List getInputUserNames() { return Arrays.asList(sc.nextLine().split(DELIMITER)); } - private static LadderHeight getHeight() { + static List createUsersFrom(List userNames) { + List 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()); } diff --git a/src/main/java/LadderGenerator.java b/src/main/java/LadderGenerator.java index b089581..a1737f2 100644 --- a/src/main/java/LadderGenerator.java +++ b/src/main/java/LadderGenerator.java @@ -23,8 +23,8 @@ public List generateRows(int numOfColumn, int height) { return rows; } - public Ladder generateLadder(int lenOfRow, int height) { - return Ladder.with(generateRows(lenOfRow, height)); + public Ladder generateLadder(int numOfColumn, int height) { + return Ladder.with(generateRows(numOfColumn, height)); } public RowGeneratorStrategy getRowGeneratorStrategy() { diff --git a/src/main/java/LadderInputData.java b/src/main/java/LadderInputData.java index 08b2563..d82401c 100644 --- a/src/main/java/LadderInputData.java +++ b/src/main/java/LadderInputData.java @@ -2,16 +2,27 @@ public class LadderInputData { + public static final String ERROR_USER_NUMS_PRIZE_NUMS_NOT_EQUAL = "참가자 수와 게임 상품 수가 일치하지 않습니다."; + private List users; private LadderHeight height; + private List prizes; - private LadderInputData(List users, LadderHeight height) { + private LadderInputData(List users, LadderHeight height, List prizes) { + validate(users, prizes); this.users = users; this.height = height; + this.prizes = prizes; + } + + private void validate(List users, List prizes) { + if (users.size() != prizes.size()) { + throw new IllegalArgumentException(ERROR_USER_NUMS_PRIZE_NUMS_NOT_EQUAL); + } } - public static LadderInputData of(List users, LadderHeight height) { - return new LadderInputData(users, height); + public static LadderInputData of(List users, LadderHeight height, List prizes) { + return new LadderInputData(users, height, prizes); } public List getUsers() { @@ -21,4 +32,8 @@ public List getUsers() { public LadderHeight getHeight() { return height; } + + public List getPrizes() { + return prizes; + } } diff --git a/src/main/java/Prize.java b/src/main/java/Prize.java new file mode 100644 index 0000000..1df903d --- /dev/null +++ b/src/main/java/Prize.java @@ -0,0 +1,22 @@ +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; + } +} diff --git a/src/test/java/ConsoleInputTest.java b/src/test/java/ConsoleInputTest.java index 5b7a663..90fb07c 100644 --- a/src/test/java/ConsoleInputTest.java +++ b/src/test/java/ConsoleInputTest.java @@ -6,16 +6,20 @@ import static org.assertj.core.api.Assertions.assertThat; class ConsoleInputTest { - public static List getUsersFixture(String name) { - return ConsoleInput.getUsers(Arrays.asList(name.split(","))); + public static List getUsersFixture(String userName) { + return ConsoleInput.createUsersFrom(Arrays.asList(userName.split(","))); + } + + public static List getPrizesFixture(String prizeName) { + return ConsoleInput.createPrizesFrom(Arrays.asList(prizeName.split(","))); } @Test - void getUsers_ValidInput_ValidOutput() { + void createUsers_ValidInput_ValidOutput() { // given List userNames = Arrays.asList("김지우,조광일".split(",")); // when - List users = ConsoleInput.getUsers(userNames); + List users = ConsoleInput.createUsersFrom(userNames); // then assertThat(users).hasSize(2); assertThat(users.get(0).getUserName().getName()).isEqualTo("김지우"); @@ -23,4 +27,18 @@ void getUsers_ValidInput_ValidOutput() { assertThat(users.get(1).getUserName().getName()).isEqualTo("조광일"); assertThat(users.get(1).getPosition()).isEqualTo(1); } + + @Test + void createPrizes_ValidInput_ValidOutput() { + // given + List prizeNames = Arrays.asList("꽝,3000".split(",")); + // when + List 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); + } } \ No newline at end of file diff --git a/src/test/java/LadderGameTest.java b/src/test/java/LadderGameTest.java index 88a6beb..1f80b78 100644 --- a/src/test/java/LadderGameTest.java +++ b/src/test/java/LadderGameTest.java @@ -10,7 +10,8 @@ void with_ValidInput_ValidOutput() { // given List users = ConsoleInputTest.getUsersFixture("김지우,조광일,구미향"); LadderHeight height = LadderHeightTest.getLadderHeightFixture(3); - LadderInputData ladderInputData = LadderInputData.of(users, height); + List prizes = ConsoleInputTest.getPrizesFixture("꽝,3000,꽝"); + LadderInputData ladderInputData = LadderInputData.of(users, height, prizes); RowGeneratorStrategy rowGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy(); // when LadderGame ladderGame = LadderGame.with(ladderInputData, rowGeneratorStrategy); @@ -23,16 +24,18 @@ void with_ValidInput_ValidOutput() { @Test void generateLadder_ManualStrategy_ValidLadder() { // given - String names = "김지우,조광일,구미향"; + String userNames = "김지우,조광일,구미향"; + String prizeNames = "꽝,3000,꽝"; int numOfNames = 3; + int lenOfRow = numOfNames - 1; int height = 4; - Row rowFixture = RowTest.getRowFixture(numOfNames); - LadderInputData ladderInputData = LadderInputDataTest.getLadderInputDataFixture(names, height); + Row rowFixture = RowTest.getRowFixture(lenOfRow); + LadderInputData ladderInputData = LadderInputDataTest.getLadderInputDataFixture(userNames, height, prizeNames); RowGeneratorStrategy rowGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy(); LadderGame ladderGame = LadderGame.with(ladderInputData, rowGeneratorStrategy); // when ladderGame.generateLadder(); - // then 테스트 코드들을 관통하는 Fixture + // 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 index 4e16959..232f979 100644 --- a/src/test/java/LadderGeneratorTest.java +++ b/src/test/java/LadderGeneratorTest.java @@ -8,12 +8,13 @@ public class LadderGeneratorTest { @Test void generateLadder_InputManualStrategy() { // given - int numOfGenerableColumn = 3; + int numOfUsers = 3; + int lenOfRow = numOfUsers - 1; int height = 4; LadderGenerator ladderGenerator = LadderGenerator.with(new RowWithEvenIndexLinesGeneratorStrategy()); - Row RowWithEvenIndexLinesFixture = RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexRowFixture(numOfGenerableColumn); + Row RowWithEvenIndexLinesFixture = RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexRowFixture(lenOfRow); // when - Ladder ladder = ladderGenerator.generateLadder(numOfGenerableColumn, height); + Ladder ladder = ladderGenerator.generateLadder(numOfUsers, height); // then assertThat(ladder.getRows()).hasSize(height); assertThat(ladder.getRows()).contains(RowWithEvenIndexLinesFixture); @@ -22,12 +23,12 @@ void generateLadder_InputManualStrategy() { @Test void generateRows_InputManualStrategy() { // given - int numOfGenerableColumn = 3; - int numOfEvenIndexLines = numOfGenerableColumn / 2 + 1; + int numOfUsers = 3; + int numOfEvenIndexLines = numOfUsers / 2; int height = 4; LadderGenerator ladderGenerator = LadderGenerator.with(new RowWithEvenIndexLinesGeneratorStrategy()); // when - List rows = ladderGenerator.generateRows(numOfGenerableColumn, height); + List rows = ladderGenerator.generateRows(numOfUsers, height); // then assertThat(rows).hasSize(height); assertThat(rows.get(0).getLines()).hasSize(numOfEvenIndexLines); diff --git a/src/test/java/LadderInputDataTest.java b/src/test/java/LadderInputDataTest.java index 35ade2c..bd1b15c 100644 --- a/src/test/java/LadderInputDataTest.java +++ b/src/test/java/LadderInputDataTest.java @@ -4,12 +4,14 @@ import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; public class LadderInputDataTest { - public static LadderInputData getLadderInputDataFixture(String name, int height) { - List users = ConsoleInputTest.getUsersFixture(name); + public static LadderInputData getLadderInputDataFixture(String userName, int height, String prizeName) { + List users = ConsoleInputTest.getUsersFixture(userName); LadderHeight ladderHeight = LadderHeightTest.getLadderHeightFixture(height); - return LadderInputData.of(users, ladderHeight); + List prizes = ConsoleInputTest.getPrizesFixture(prizeName); + return LadderInputData.of(users, ladderHeight, prizes); } @Test @@ -19,10 +21,27 @@ void of_ValidInput_ValidOutput() { users.add(User.with(UserName.of("김지우"),0)); users.add(User.with(UserName.of("조광일"),1)); LadderHeight height = LadderHeight.of(1); + List prizes = new ArrayList<>(); + prizes.add(Prize.with("꽝",0)); + prizes.add(Prize.with("3000",1)); // when - LadderInputData ladderInputData = LadderInputData.of(users, height); + LadderInputData ladderInputData = LadderInputData.of(users, height, prizes); // then assertThat(ladderInputData.getUsers()).isEqualTo(users); assertThat(ladderInputData.getHeight()).isEqualTo(height); + assertThat(ladderInputData.getPrizes()).isEqualTo(prizes); + } + + @Test + void of_InvalidInput_ThrowException() { + // given + List users = new ArrayList<>(); + users.add(User.with(UserName.of("김지우"),0)); + LadderHeight height = LadderHeight.of(1); + List prizes = new ArrayList<>(); + prizes.add(Prize.with("꽝",0)); + prizes.add(Prize.with("3000",1)); + // then + assertThatThrownBy(() -> LadderInputData.of(users, height, prizes)).isInstanceOf(IllegalArgumentException.class); } } 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 From cb7e9b97b1cfe32332cac6a93170fd6a292b5a33 Mon Sep 17 00:00:00 2001 From: jiwoo Date: Tue, 28 Jan 2020 17:56:06 +0900 Subject: [PATCH 10/12] feat : ladder game run - add field 'ladderGameResult' in LadderGame.java --- README.md | 2 + src/main/java/Ladder.java | 8 ++++ src/main/java/LadderGame.java | 18 ++++++++- src/main/java/Line.java | 4 ++ src/main/java/Prize.java | 4 ++ src/main/java/Row.java | 20 ++++++++++ src/test/java/LadderGameTest.java | 2 +- src/test/java/LadderTest.java | 61 ++++++++++++++++++++++++++++++- src/test/java/RowTest.java | 40 +++++++++++++++++++- 9 files changed, 154 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index f21ff34..93dcbde 100644 --- a/README.md +++ b/README.md @@ -26,3 +26,5 @@ - 사다리 출력하기 - 사용자 이름과 사다리를 함께 출력해야한다. + +- 사다리 게임 실행하기 \ No newline at end of file diff --git a/src/main/java/Ladder.java b/src/main/java/Ladder.java index be55657..3e1098e 100644 --- a/src/main/java/Ladder.java +++ b/src/main/java/Ladder.java @@ -12,6 +12,14 @@ public static Ladder with(List 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 getRows() { return rows; } diff --git a/src/main/java/LadderGame.java b/src/main/java/LadderGame.java index 3ed2222..416b217 100644 --- a/src/main/java/LadderGame.java +++ b/src/main/java/LadderGame.java @@ -1,3 +1,4 @@ +import java.util.HashMap; import java.util.List; public class LadderGame { @@ -7,12 +8,15 @@ public class LadderGame { private List users; private LadderHeight height; - private LadderGenerator ladderGenerator; + private List prizes; private Ladder ladder; + private LadderGenerator ladderGenerator; + private HashMap ladderResult = new HashMap<>(); private LadderGame(LadderInputData ladderInputData, RowGeneratorStrategy rowGeneratorStrategy) { this.users = ladderInputData.getUsers(); this.height = ladderInputData.getHeight(); + this.prizes = ladderInputData.getPrizes(); // TODO 생성자에서 데이터를 넣어주느냐 vs 메서드 파라미터로 넣어주느냐 ( 각각 어떤 변화들을 야기하는가?!) // TODO 파라미터로 넣어주면 generateRows에 자유도가 생김. this.ladderGenerator = new LadderGenerator(rowGeneratorStrategy); @@ -27,6 +31,18 @@ public void generateLadder() { 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 List getUsers() { return users; } diff --git a/src/main/java/Line.java b/src/main/java/Line.java index 07cd0ae..9b5d4e2 100644 --- a/src/main/java/Line.java +++ b/src/main/java/Line.java @@ -18,6 +18,10 @@ public boolean isStartingWith(int position) { return startPosition == position; } + public boolean isEndingWith(int position) { + return endPosition == position; + } + public int getStartPosition() { return startPosition; } diff --git a/src/main/java/Prize.java b/src/main/java/Prize.java index 1df903d..dd77202 100644 --- a/src/main/java/Prize.java +++ b/src/main/java/Prize.java @@ -19,4 +19,8 @@ public String getPrizeName() { public int getPosition() { return position; } + + public boolean hasPosition(int position) { + return this.position == position; + } } diff --git a/src/main/java/Row.java b/src/main/java/Row.java index c1b85d4..4238e26 100644 --- a/src/main/java/Row.java +++ b/src/main/java/Row.java @@ -43,6 +43,26 @@ private String getLineStartingWith(int point) { return BLANK_SPACE_BETWEEN_BARS; } + public int getNextPosition(int prevPosition) { + if (hasLineStartingWith(prevPosition)) { + return prevPosition + 1; + } + + if (hasLineEndingWith(prevPosition)) { + return prevPosition - 1; + } + + return prevPosition; + } + + private 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 getLines() { return lines; } diff --git a/src/test/java/LadderGameTest.java b/src/test/java/LadderGameTest.java index 1f80b78..235e740 100644 --- a/src/test/java/LadderGameTest.java +++ b/src/test/java/LadderGameTest.java @@ -29,7 +29,7 @@ void generateLadder_ManualStrategy_ValidLadder() { int numOfNames = 3; int lenOfRow = numOfNames - 1; int height = 4; - Row rowFixture = RowTest.getRowFixture(lenOfRow); + Row rowFixture = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow); LadderInputData ladderInputData = LadderInputDataTest.getLadderInputDataFixture(userNames, height, prizeNames); RowGeneratorStrategy rowGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy(); LadderGame ladderGame = LadderGame.with(ladderInputData, rowGeneratorStrategy); diff --git a/src/test/java/LadderTest.java b/src/test/java/LadderTest.java index 0d49699..bb1ebc1 100644 --- a/src/test/java/LadderTest.java +++ b/src/test/java/LadderTest.java @@ -11,11 +11,68 @@ void with_ValidInput_ValidOutput() { // given List rows = new ArrayList<>(); int numOfLines = 3; - rows.add(RowTest.getRowFixture(numOfLines)); - rows.add(RowTest.getRowFixture(numOfLines)); + 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 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 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 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/RowTest.java b/src/test/java/RowTest.java index 18e657e..8c4cec8 100644 --- a/src/test/java/RowTest.java +++ b/src/test/java/RowTest.java @@ -6,7 +6,7 @@ import static org.assertj.core.api.Assertions.assertThat; public class RowTest { - public static Row getRowFixture(int lenOfRow) { + public static Row getRowFixtureWithLinesStartingWithEvenIndex(int lenOfRow) { return Row.of(lenOfRow, RowWithEvenIndexLinesGeneratorStrategyTest.getEvenIndexLinesFixture(lenOfRow)); } @@ -23,4 +23,42 @@ void of_ValidInput_ValidOutput() { 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); + } } From 7961290579a506e7c2442f96292873c27a951527 Mon Sep 17 00:00:00 2001 From: jiwoo Date: Fri, 31 Jan 2020 18:09:11 +0900 Subject: [PATCH 11/12] feat : show userName, ladder and prizeName --- README.md | 8 +-- src/main/java/Application.java | 8 ++- src/main/java/ConsoleInput.java | 21 +++++- src/main/java/ConsoleOutput.java | 69 +++++++++++++++++++ src/main/java/Ladder.java | 4 -- src/main/java/LadderGame.java | 40 +++-------- ...nputData.java => LadderGameInputData.java} | 8 +-- src/main/java/LadderGameOutputData.java | 38 ++++++++++ src/main/java/Row.java | 30 +------- src/main/java/User.java | 4 -- src/main/java/UserName.java | 11 --- src/test/java/ConsoleInputTest.java | 16 +++++ ...Test.java => LadderGameInputDataTest.java} | 16 ++--- src/test/java/LadderGameTest.java | 8 +-- 14 files changed, 177 insertions(+), 104 deletions(-) create mode 100644 src/main/java/ConsoleOutput.java rename src/main/java/{LadderInputData.java => LadderGameInputData.java} (72%) create mode 100644 src/main/java/LadderGameOutputData.java rename src/test/java/{LadderInputDataTest.java => LadderGameInputDataTest.java} (65%) diff --git a/README.md b/README.md index 93dcbde..e794c0c 100644 --- a/README.md +++ b/README.md @@ -22,9 +22,9 @@ - 사다리 라인이 겹치지 않도록 해야한다. - +- 사다리 게임 실행하기 + - 사다리 출력하기 - - 사용자 이름과 사다리를 함께 출력해야한다. - -- 사다리 게임 실행하기 \ No newline at end of file + - 사용자 이름, 사다리 그리고 상품 이름을 함께 출력해야한다. + \ No newline at end of file diff --git a/src/main/java/Application.java b/src/main/java/Application.java index 2e45136..811fe9c 100644 --- a/src/main/java/Application.java +++ b/src/main/java/Application.java @@ -1,8 +1,10 @@ public class Application { public static void main(String[] args) { - LadderInputData ladderInputData = ConsoleInput.getLadderData(); - LadderGame ladderGame = LadderGame.with(ladderInputData, new RandomRowGeneratorStrategy()); + LadderGameInputData ladderGameInputData = ConsoleInput.getLadderGameInputData(); + LadderGame ladderGame = LadderGame.with(ladderGameInputData, new RandomRowGeneratorStrategy()); ladderGame.generateLadder(); - ladderGame.showLadderGame(); + ladderGame.run(); + LadderGameOutputData ladderGameOutputData = ladderGame.getLadderGameOutputData(); + ConsoleOutput.showLadderGameResultWith(ladderGameOutputData); } } diff --git a/src/main/java/ConsoleInput.java b/src/main/java/ConsoleInput.java index e192c73..8ef3b44 100644 --- a/src/main/java/ConsoleInput.java +++ b/src/main/java/ConsoleInput.java @@ -10,14 +10,15 @@ public class ConsoleInput { 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 LadderInputData getLadderData() { + public static LadderGameInputData getLadderGameInputData() { List users = createUsersFrom(getInputUserNames()); LadderHeight height = createHeight(); List prizes = createPrizesFrom(getInputPrizeNames()); - return LadderInputData.of(users, height, prizes); + return LadderGameInputData.of(users, height, prizes); } private static List getInputPrizeNames() { @@ -60,6 +61,20 @@ private static LadderHeight createHeight() { } private static int getInputHeight() { - return sc.nextInt(); + 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..02dc8cb --- /dev/null +++ b/src/main/java/ConsoleOutput.java @@ -0,0 +1,69 @@ +import java.util.List; +import java.util.Map; + +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 LINE = "-----"; + public static final String EMPTY = " "; + public static final String INITIAL_STRING = ""; + public static final String BAR = "|"; + private static final int MAXIMUM_LENGTH = 5; + + public static void showLadderGameResultWith(LadderGameOutputData ladderGameOutputData) { + showLadderGame(ladderGameOutputData.getUsers(), ladderGameOutputData.getLadder(), ladderGameOutputData.getPrizes()); + showGameResult(ladderGameOutputData.getLadderResult()); + } + + private static void showLadderGame(List users, Ladder ladder, List prizes) { + System.out.println(MESSAGE_LADDER_GAME_RESULT); + showUsers(users); + showLadder(ladder); + showPrizes(prizes); + } + + private static void showUsers(List users) { + users.forEach(user -> showNameToMaximumLength(user.getUserName().getName())); + System.out.print(NEXT_LINE); + } + + private static void showPrizes(List 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, " "); + System.out.print(blank + name); + System.out.print(BLANK_BETWEEN_NAMES); + } + + private static void showLadder(Ladder ladder) { + List rows = ladder.getRows(); + rows.forEach(ConsoleOutput::showRow); + } + + private static void showRow(Row row) { + System.out.print(" "); + String rowStr = INITIAL_STRING; + for (int position=0; position prizes) { + + } +} diff --git a/src/main/java/Ladder.java b/src/main/java/Ladder.java index 3e1098e..3667e43 100644 --- a/src/main/java/Ladder.java +++ b/src/main/java/Ladder.java @@ -23,8 +23,4 @@ public int startWith(int initialPosition) { public List getRows() { return rows; } - - public void show() { - rows.forEach(Row::show); - } } diff --git a/src/main/java/LadderGame.java b/src/main/java/LadderGame.java index 416b217..ec59e75 100644 --- a/src/main/java/LadderGame.java +++ b/src/main/java/LadderGame.java @@ -3,9 +3,6 @@ public class LadderGame { - public static final String BLANK_BETWEEN_NAMES = " "; - public static final String NEXT = "\n"; - private List users; private LadderHeight height; private List prizes; @@ -13,17 +10,17 @@ public class LadderGame { private LadderGenerator ladderGenerator; private HashMap ladderResult = new HashMap<>(); - private LadderGame(LadderInputData ladderInputData, RowGeneratorStrategy rowGeneratorStrategy) { - this.users = ladderInputData.getUsers(); - this.height = ladderInputData.getHeight(); - this.prizes = ladderInputData.getPrizes(); + 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(LadderInputData ladderInputData, RowGeneratorStrategy rowGeneratorStrategy) { - return new LadderGame(ladderInputData, rowGeneratorStrategy); + public static LadderGame with(LadderGameInputData ladderGameInputData, RowGeneratorStrategy rowGeneratorStrategy) { + return new LadderGame(ladderGameInputData, rowGeneratorStrategy); } public void generateLadder() { @@ -43,6 +40,10 @@ private void runWith(User user) { ladderResult.put(user, prize); } + public LadderGameOutputData getLadderGameOutputData() { + return LadderGameOutputData.of(users, prizes, ladder, ladderResult); + } + public List getUsers() { return users; } @@ -58,25 +59,4 @@ public LadderGenerator getLadderGenerator() { public Ladder getLadder() { return ladder; } - - public void showLadderGame() { - showUsers(); - showLadder(); - } - - private void showUsers() { - for (User user: users) { - user.showUserName(); - System.out.print(BLANK_BETWEEN_NAMES); - } - moveToNextRow(); - } - - private void moveToNextRow() { - System.out.print(NEXT); - } - - private void showLadder() { - ladder.show(); - } } diff --git a/src/main/java/LadderInputData.java b/src/main/java/LadderGameInputData.java similarity index 72% rename from src/main/java/LadderInputData.java rename to src/main/java/LadderGameInputData.java index d82401c..db5808e 100644 --- a/src/main/java/LadderInputData.java +++ b/src/main/java/LadderGameInputData.java @@ -1,6 +1,6 @@ import java.util.List; -public class LadderInputData { +public class LadderGameInputData { public static final String ERROR_USER_NUMS_PRIZE_NUMS_NOT_EQUAL = "참가자 수와 게임 상품 수가 일치하지 않습니다."; @@ -8,7 +8,7 @@ public class LadderInputData { private LadderHeight height; private List prizes; - private LadderInputData(List users, LadderHeight height, List prizes) { + private LadderGameInputData(List users, LadderHeight height, List prizes) { validate(users, prizes); this.users = users; this.height = height; @@ -21,8 +21,8 @@ private void validate(List users, List prizes) { } } - public static LadderInputData of(List users, LadderHeight height, List prizes) { - return new LadderInputData(users, height, prizes); + public static LadderGameInputData of(List users, LadderHeight height, List prizes) { + return new LadderGameInputData(users, height, prizes); } public List getUsers() { 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 users; + private List prizes; + private Ladder ladder; + private Map ladderResult; + + private LadderGameOutputData(List users, List prizes, Ladder ladder, Map ladderResult) { + this.users = users; + this.prizes = prizes; + this.ladder = ladder; + this.ladderResult = ladderResult; + } + + public static LadderGameOutputData of(List users, List prizes, Ladder ladder, HashMap ladderResult) { + return new LadderGameOutputData(users, prizes, ladder, ladderResult); + } + + public List getUsers() { + return users; + } + + public List getPrizes() { + return prizes; + } + + public Ladder getLadder() { + return ladder; + } + + public Map getLadderResult() { + return ladderResult; + } +} diff --git a/src/main/java/Row.java b/src/main/java/Row.java index 4238e26..8aa7bc9 100644 --- a/src/main/java/Row.java +++ b/src/main/java/Row.java @@ -3,11 +3,6 @@ public class Row { - public static final String ROW_BAR = "|"; - public static final String LINE = "-----"; - public static final String BLANK_SPACE_BETWEEN_BARS = " "; - public static final String HEAD_OF_ROW = " "; - private int lenOfRow; private List lines; @@ -20,29 +15,6 @@ public static Row of(int lenOfRow, List lines) { return new Row(lenOfRow, lines); } - public void show() { - String row = rowToString(); - System.out.print(HEAD_OF_ROW); - System.out.println(row); - } - - private String rowToString() { - String row = ""; - for (int position=0; position line.isStartingWith(point)); - if (isLineStartingWithPointExist) { - return LINE; - } - return BLANK_SPACE_BETWEEN_BARS; - } - public int getNextPosition(int prevPosition) { if (hasLineStartingWith(prevPosition)) { return prevPosition + 1; @@ -55,7 +27,7 @@ public int getNextPosition(int prevPosition) { return prevPosition; } - private boolean hasLineStartingWith(int prevPosition) { + public boolean hasLineStartingWith(int prevPosition) { return lines.stream().anyMatch(line -> line.isStartingWith(prevPosition)); } diff --git a/src/main/java/User.java b/src/main/java/User.java index ee47dc4..9eeb945 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -19,8 +19,4 @@ public UserName getUserName() { public int getPosition() { return position; } - - public void showUserName() { - userName.show(); - } } diff --git a/src/main/java/UserName.java b/src/main/java/UserName.java index 5416304..fbdca40 100644 --- a/src/main/java/UserName.java +++ b/src/main/java/UserName.java @@ -2,8 +2,6 @@ public class UserName { public static final int THRESHOLD = 5; public static final String ERROR_NAME_LENGTH_EXCEEDED = "이름이 5자 넘었습니다."; - public static final String BLANK_SPACE = " "; - public static final String NULL = "\0"; private final String name; @@ -25,13 +23,4 @@ private static void validate(String name) { public String getName() { return name; } - - public void show() { - int blankSpaceNums = 5 - name.length(); - System.out.print(getBlankSpace(blankSpaceNums) + name); - } - - private String getBlankSpace(int blankSpaceNums) { - return new String(new char[blankSpaceNums]).replace(NULL, BLANK_SPACE); - } } diff --git a/src/test/java/ConsoleInputTest.java b/src/test/java/ConsoleInputTest.java index 90fb07c..1efccd8 100644 --- a/src/test/java/ConsoleInputTest.java +++ b/src/test/java/ConsoleInputTest.java @@ -41,4 +41,20 @@ void createPrizes_ValidInput_ValidOutput() { 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/LadderInputDataTest.java b/src/test/java/LadderGameInputDataTest.java similarity index 65% rename from src/test/java/LadderInputDataTest.java rename to src/test/java/LadderGameInputDataTest.java index bd1b15c..6bee7cf 100644 --- a/src/test/java/LadderInputDataTest.java +++ b/src/test/java/LadderGameInputDataTest.java @@ -6,12 +6,12 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -public class LadderInputDataTest { - public static LadderInputData getLadderInputDataFixture(String userName, int height, String prizeName) { +public class LadderGameInputDataTest { + public static LadderGameInputData getLadderInputDataFixture(String userName, int height, String prizeName) { List users = ConsoleInputTest.getUsersFixture(userName); LadderHeight ladderHeight = LadderHeightTest.getLadderHeightFixture(height); List prizes = ConsoleInputTest.getPrizesFixture(prizeName); - return LadderInputData.of(users, ladderHeight, prizes); + return LadderGameInputData.of(users, ladderHeight, prizes); } @Test @@ -25,11 +25,11 @@ void of_ValidInput_ValidOutput() { prizes.add(Prize.with("꽝",0)); prizes.add(Prize.with("3000",1)); // when - LadderInputData ladderInputData = LadderInputData.of(users, height, prizes); + LadderGameInputData ladderGameInputData = LadderGameInputData.of(users, height, prizes); // then - assertThat(ladderInputData.getUsers()).isEqualTo(users); - assertThat(ladderInputData.getHeight()).isEqualTo(height); - assertThat(ladderInputData.getPrizes()).isEqualTo(prizes); + assertThat(ladderGameInputData.getUsers()).isEqualTo(users); + assertThat(ladderGameInputData.getHeight()).isEqualTo(height); + assertThat(ladderGameInputData.getPrizes()).isEqualTo(prizes); } @Test @@ -42,6 +42,6 @@ void of_InvalidInput_ThrowException() { prizes.add(Prize.with("꽝",0)); prizes.add(Prize.with("3000",1)); // then - assertThatThrownBy(() -> LadderInputData.of(users, height, prizes)).isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> LadderGameInputData.of(users, height, prizes)).isInstanceOf(IllegalArgumentException.class); } } diff --git a/src/test/java/LadderGameTest.java b/src/test/java/LadderGameTest.java index 235e740..a0637c3 100644 --- a/src/test/java/LadderGameTest.java +++ b/src/test/java/LadderGameTest.java @@ -11,10 +11,10 @@ void with_ValidInput_ValidOutput() { List users = ConsoleInputTest.getUsersFixture("김지우,조광일,구미향"); LadderHeight height = LadderHeightTest.getLadderHeightFixture(3); List prizes = ConsoleInputTest.getPrizesFixture("꽝,3000,꽝"); - LadderInputData ladderInputData = LadderInputData.of(users, height, prizes); + LadderGameInputData ladderGameInputData = LadderGameInputData.of(users, height, prizes); RowGeneratorStrategy rowGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy(); // when - LadderGame ladderGame = LadderGame.with(ladderInputData, rowGeneratorStrategy); + LadderGame ladderGame = LadderGame.with(ladderGameInputData, rowGeneratorStrategy); // then assertThat(ladderGame.getUsers()).isEqualTo(users); assertThat(ladderGame.getHeight()).isEqualTo(height); @@ -30,9 +30,9 @@ void generateLadder_ManualStrategy_ValidLadder() { int lenOfRow = numOfNames - 1; int height = 4; Row rowFixture = RowTest.getRowFixtureWithLinesStartingWithEvenIndex(lenOfRow); - LadderInputData ladderInputData = LadderInputDataTest.getLadderInputDataFixture(userNames, height, prizeNames); + LadderGameInputData ladderGameInputData = LadderGameInputDataTest.getLadderInputDataFixture(userNames, height, prizeNames); RowGeneratorStrategy rowGeneratorStrategy = new RowWithEvenIndexLinesGeneratorStrategy(); - LadderGame ladderGame = LadderGame.with(ladderInputData, rowGeneratorStrategy); + LadderGame ladderGame = LadderGame.with(ladderGameInputData, rowGeneratorStrategy); // when ladderGame.generateLadder(); // then From e788a14ebe880d7b7687e5b594c697f75cae1c4b Mon Sep 17 00:00:00 2001 From: jiwoo Date: Fri, 31 Jan 2020 19:09:29 +0900 Subject: [PATCH 12/12] feat : show ladder game result --- README.md | 9 ++++++- src/main/java/ConsoleOutput.java | 46 ++++++++++++++++++++++++-------- src/main/java/Row.java | 10 +++++++ src/main/java/User.java | 6 +++++ src/main/java/UserName.java | 15 +++++++++++ src/test/java/UserTest.java | 18 +++++++++++++ 6 files changed, 92 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index e794c0c..1746eb2 100644 --- a/README.md +++ b/README.md @@ -27,4 +27,11 @@ - 사다리 출력하기 - 사용자 이름, 사다리 그리고 상품 이름을 함께 출력해야한다. - \ No newline at end of file + + - 결과를 보여준다. + + - 한 사람을 물어보면 그 사람 결과를 보여준다. + + - all 이라 입력하면 전체 결과를 보여준다. + + - 없는 사람을 물어보면 없다는 메세지를 보여준다. \ No newline at end of file diff --git a/src/main/java/ConsoleOutput.java b/src/main/java/ConsoleOutput.java index 02dc8cb..5ebb817 100644 --- a/src/main/java/ConsoleOutput.java +++ b/src/main/java/ConsoleOutput.java @@ -1,5 +1,6 @@ import java.util.List; import java.util.Map; +import java.util.Scanner; public class ConsoleOutput { @@ -7,11 +8,17 @@ public class ConsoleOutput { public static final String NULL = "\0"; public static final String BLANK_BETWEEN_NAMES = " "; public static final String NEXT_LINE = "\n"; - public static final String LINE = "-----"; - public static final String EMPTY = " "; 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()); @@ -37,7 +44,7 @@ private static void showPrizes(List prizes) { private static void showNameToMaximumLength(String name) { int blankSpaceNums = MAXIMUM_LENGTH - name.length(); - String blank = new String(new char[blankSpaceNums]).replace(NULL, " "); + String blank = new String(new char[blankSpaceNums]).replace(NULL, BLANK); System.out.print(blank + name); System.out.print(BLANK_BETWEEN_NAMES); } @@ -48,22 +55,39 @@ private static void showLadder(Ladder ladder) { } private static void showRow(Row row) { - System.out.print(" "); + System.out.print(LEFT_MARGIN); String rowStr = INITIAL_STRING; for (int position=0; position 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 prizes) { + for (User user: prizes.keySet()) { + System.out.println(user.getUserName().getName() + DELIMITER + prizes.get(user).getPrizeName()); + } + } + + private static void showUserResult(String name, Map 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/Row.java b/src/main/java/Row.java index 8aa7bc9..1bbeb36 100644 --- a/src/main/java/Row.java +++ b/src/main/java/Row.java @@ -3,6 +3,9 @@ public class Row { + public static final String LINE = "-----"; + public static final String EMPTY_LINE = " "; + private int lenOfRow; private List lines; @@ -27,6 +30,13 @@ public int getNextPosition(int prevPosition) { 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)); } diff --git a/src/main/java/User.java b/src/main/java/User.java index 9eeb945..c822fc6 100644 --- a/src/main/java/User.java +++ b/src/main/java/User.java @@ -1,3 +1,5 @@ +import java.util.Objects; + public class User { private final UserName userName; @@ -19,4 +21,8 @@ public UserName getUserName() { 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 index fbdca40..58077ac 100644 --- a/src/main/java/UserName.java +++ b/src/main/java/UserName.java @@ -1,3 +1,5 @@ +import java.util.Objects; + public class UserName { public static final int THRESHOLD = 5; @@ -23,4 +25,17 @@ private static void validate(String name) { 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/test/java/UserTest.java b/src/test/java/UserTest.java index 36d2878..cf17718 100644 --- a/src/test/java/UserTest.java +++ b/src/test/java/UserTest.java @@ -14,4 +14,22 @@ void with_ValidInput_ValidOutput() { 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(); + } }