diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000..f2f8d5d --- /dev/null +++ b/docs/README.md @@ -0,0 +1,27 @@ +## 기능 요구 사항 + +**버전** + +- [ ] 숫자 버전은 1번이다. +- [ ] 영어 버전은 2번이다. + +**난수** + +- [x] 숫자 버전은 1 ~ 100 사이의 정답을 가진다. +- [ ] 영어 버전은 A ~ z 사이의 정답을 가진다. + +**정답** + +- [x] 추측값과 정답을 비교한다. +- [x] 게임 상태를 반환한다. + +**게임 상태** + +- [x] 추측값이 정답보다 작은 경우 UP 상태이다. +- [x] 추측값이 정답보다 큰 경우 DOWN 상태이다. +- [x] 추측값이 정답과 일치하는 경우 CORRECT 상태이다. + +**시도 횟수** + +- [ ] 사용자가 정답을 맞출 때까지 시도한 횟수를 출력한다 + - 잘못된 값 입력 역시 시도한 횟수에 포함 되어야 한다. diff --git a/src/main/java/leets/land/UpdownApplication.java b/src/main/java/leets/land/UpdownApplication.java index 09d7ae5..4c512f8 100644 --- a/src/main/java/leets/land/UpdownApplication.java +++ b/src/main/java/leets/land/UpdownApplication.java @@ -1,8 +1,11 @@ package leets.land; +import leets.land.controller.GameLoader; + public class UpdownApplication { - public static void main(String[] args) { - System.out.print("hihi :D"); - } + public static void main(String[] args) { + GameLoader gameLoader = new GameLoader(); + gameLoader.load(); + } } diff --git a/src/main/java/leets/land/controller/AlphabetGameMachine.java b/src/main/java/leets/land/controller/AlphabetGameMachine.java new file mode 100644 index 0000000..b9188a8 --- /dev/null +++ b/src/main/java/leets/land/controller/AlphabetGameMachine.java @@ -0,0 +1,41 @@ +package leets.land.controller; + +import leets.land.domain.guess.GuessAlphabet; +import leets.land.domain.guess.GuessRange; +import leets.land.domain.status.GuessStatus; +import leets.land.domain.updowngame.AlphabetUpDownGame; +import leets.land.domain.updowngame.UpDownGame; +import leets.land.view.InputView; +import leets.land.view.OutputView; + +public class AlphabetGameMachine implements GameMachine { + + private final InputView inputView = new InputView(); + private final OutputView outputView = new OutputView(); + + @Override + public void run() { + UpDownGame upDownGame = new AlphabetUpDownGame(); + play(upDownGame); + } + + private void play(UpDownGame upDownGame) { + GuessAlphabet guessAlphabet = readGuessAlphabetInRange(upDownGame.guessRange()); + GuessStatus guessStatus = upDownGame.play(guessAlphabet); + outputView.printGuessStatus(guessStatus); + if (guessStatus.isContinue()) { + play(upDownGame); + } + } + + private GuessAlphabet readGuessAlphabetInRange(GuessRange guessRange) { + try { + int guessValue = inputView.readGuessAlphabetInRange(guessRange.min(), guessRange.max()); + guessRange.checkRange(guessValue); + return new GuessAlphabet(guessValue); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + return readGuessAlphabetInRange(guessRange); + } + } +} diff --git a/src/main/java/leets/land/controller/GameLoader.java b/src/main/java/leets/land/controller/GameLoader.java new file mode 100644 index 0000000..ad6e9ef --- /dev/null +++ b/src/main/java/leets/land/controller/GameLoader.java @@ -0,0 +1,19 @@ +package leets.land.controller; + +import leets.land.domain.GameVersion; +import leets.land.view.InputView; + +public class GameLoader { + + private final InputView inputView = new InputView(); + + public void load() { + GameVersion gameVersion = readGameVersion(); + gameVersion.start(); + } + + private GameVersion readGameVersion() { + int gameVersion = inputView.readGameVersion(); + return GameVersion.match(gameVersion); + } +} diff --git a/src/main/java/leets/land/controller/GameMachine.java b/src/main/java/leets/land/controller/GameMachine.java new file mode 100644 index 0000000..0dce157 --- /dev/null +++ b/src/main/java/leets/land/controller/GameMachine.java @@ -0,0 +1,6 @@ +package leets.land.controller; + +public interface GameMachine { + + void run(); +} diff --git a/src/main/java/leets/land/controller/NumberGameMachine.java b/src/main/java/leets/land/controller/NumberGameMachine.java new file mode 100644 index 0000000..e5fa9c8 --- /dev/null +++ b/src/main/java/leets/land/controller/NumberGameMachine.java @@ -0,0 +1,41 @@ +package leets.land.controller; + +import leets.land.domain.guess.GuessNumber; +import leets.land.domain.guess.GuessRange; +import leets.land.domain.status.GuessStatus; +import leets.land.domain.updowngame.NumberUpDownGame; +import leets.land.domain.updowngame.UpDownGame; +import leets.land.view.InputView; +import leets.land.view.OutputView; + +public class NumberGameMachine implements GameMachine { + + private final InputView inputView = new InputView(); + private final OutputView outputView = new OutputView(); + + @Override + public void run() { + UpDownGame upDownGame = new NumberUpDownGame(); + play(upDownGame); + } + + private void play(UpDownGame upDownGame) { + GuessNumber guessNumber = readGuessNumberInRange(upDownGame.guessRange()); + GuessStatus guessStatus = upDownGame.play(guessNumber); + outputView.printGuessStatus(guessStatus); + if (guessStatus.isContinue()) { + play(upDownGame); + } + } + + private GuessNumber readGuessNumberInRange(GuessRange guessRange) { + try { + int guessNumber = inputView.readGuessNumberInRange(guessRange.min(), guessRange.max()); + guessRange.checkRange(guessNumber); + return new GuessNumber(guessNumber); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + return readGuessNumberInRange(guessRange); + } + } +} diff --git a/src/main/java/leets/land/domain/AnswerNumber.java b/src/main/java/leets/land/domain/AnswerNumber.java new file mode 100644 index 0000000..6b03f65 --- /dev/null +++ b/src/main/java/leets/land/domain/AnswerNumber.java @@ -0,0 +1,18 @@ +package leets.land.domain; + +import leets.land.domain.guess.GuessValue; +import leets.land.domain.status.GuessStatus; + +public class AnswerNumber { + + private final int value; + + public AnswerNumber(int value) { + this.value = value; + } + + public GuessStatus compare(GuessValue guessValue) { + int compared = guessValue.compare(value); + return GuessStatus.match(compared); + } +} diff --git a/src/main/java/leets/land/domain/GameVersion.java b/src/main/java/leets/land/domain/GameVersion.java new file mode 100644 index 0000000..ff40a62 --- /dev/null +++ b/src/main/java/leets/land/domain/GameVersion.java @@ -0,0 +1,32 @@ +package leets.land.domain; + +import leets.land.controller.AlphabetGameMachine; +import leets.land.controller.GameMachine; +import leets.land.controller.NumberGameMachine; + +import java.util.Arrays; + +public enum GameVersion { + + NUMBER(1, new NumberGameMachine()), + ALPHABET(2, new AlphabetGameMachine()); + + private final int version; + private final GameMachine gameMachine; + + GameVersion(int version, GameMachine gameMachine) { + this.version = version; + this.gameMachine = gameMachine; + } + + public static GameVersion match(int version) { + return Arrays.stream(values()) + .filter(gameVersion -> gameVersion.version == version) + .findFirst() + .orElseThrow(() -> new IllegalArgumentException("[ERROR] 존재하지 않는 버전입니다.")); + } + + public void start() { + gameMachine.run(); + } +} diff --git a/src/main/java/leets/land/domain/guess/GuessAlphabet.java b/src/main/java/leets/land/domain/guess/GuessAlphabet.java new file mode 100644 index 0000000..691f0bb --- /dev/null +++ b/src/main/java/leets/land/domain/guess/GuessAlphabet.java @@ -0,0 +1,44 @@ +package leets.land.domain.guess; + +import java.util.Objects; + +public class GuessAlphabet implements GuessValue { + + private static final int MIN_RANGE = 'A'; + private static final int MAX_RANGE = 'z'; + private static final String ERROR_FORMAT = "[ERROR] %s"; + + private final int value; + + public GuessAlphabet(int value) { + validate(value); + this.value = value; + } + + private void validate(int value) { + if (value < MIN_RANGE || value > MAX_RANGE) { + throw new IllegalArgumentException(String.format(ERROR_FORMAT, "추측값의 범위는 A 이상 z 이하입니다")); + } + } + + public int compare(int other) { + return other - value; + } + + public int value() { + return value; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + GuessAlphabet that = (GuessAlphabet) o; + return value == that.value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } +} diff --git a/src/main/java/leets/land/domain/guess/GuessNumber.java b/src/main/java/leets/land/domain/guess/GuessNumber.java new file mode 100644 index 0000000..748050a --- /dev/null +++ b/src/main/java/leets/land/domain/guess/GuessNumber.java @@ -0,0 +1,44 @@ +package leets.land.domain.guess; + +import java.util.Objects; + +public class GuessNumber implements GuessValue { + + private static final int MIN_RANGE = 1; + private static final int MAX_RANGE = 100; + private static final String ERROR_FORMAT = "[ERROR] %s"; + + private final int value; + + public GuessNumber(int value) { + validate(value); + this.value = value; + } + + private void validate(int value) { + if (value < MIN_RANGE || value > MAX_RANGE) { + throw new IllegalArgumentException(String.format(ERROR_FORMAT, "추측값의 범위는 1 이상 100 이하입니다")); + } + } + + public int compare(int other) { + return other - value; + } + + public int value() { + return value; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + GuessNumber that = (GuessNumber) o; + return value == that.value; + } + + @Override + public int hashCode() { + return Objects.hash(value); + } +} diff --git a/src/main/java/leets/land/domain/guess/GuessRange.java b/src/main/java/leets/land/domain/guess/GuessRange.java new file mode 100644 index 0000000..fcd6d8b --- /dev/null +++ b/src/main/java/leets/land/domain/guess/GuessRange.java @@ -0,0 +1,51 @@ +package leets.land.domain.guess; + +import java.util.Objects; + +public class GuessRange { + + private static final String ERROR_FORMAT = "[ERROR] %s"; + + private final GuessValue min; + private final GuessValue max; + + public GuessRange(GuessValue min, GuessValue max) { + this.min = min; + this.max = max; + } + + public GuessRange downMax(GuessValue max) { + return new GuessRange(min, max); + } + + public GuessRange upMin(GuessValue min) { + return new GuessRange(min, max); + } + + public void checkRange(int guessValue) { + if (guessValue < min() || guessValue > max()) { + throw new IllegalArgumentException(String.format(ERROR_FORMAT, "범위를 벗어납니다.")); + } + } + + public int min() { + return min.value(); + } + + public int max() { + return max.value(); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + GuessRange that = (GuessRange) o; + return Objects.equals(min, that.min) && Objects.equals(max, that.max); + } + + @Override + public int hashCode() { + return Objects.hash(min, max); + } +} diff --git a/src/main/java/leets/land/domain/guess/GuessValue.java b/src/main/java/leets/land/domain/guess/GuessValue.java new file mode 100644 index 0000000..40fef52 --- /dev/null +++ b/src/main/java/leets/land/domain/guess/GuessValue.java @@ -0,0 +1,8 @@ +package leets.land.domain.guess; + +public interface GuessValue { + + int compare(int other); + + int value(); +} diff --git a/src/main/java/leets/land/domain/status/Correct.java b/src/main/java/leets/land/domain/status/Correct.java new file mode 100644 index 0000000..e8016c4 --- /dev/null +++ b/src/main/java/leets/land/domain/status/Correct.java @@ -0,0 +1,23 @@ +package leets.land.domain.status; + +import leets.land.domain.guess.GuessRange; +import leets.land.domain.guess.GuessValue; + +public class Correct implements Status { + + @Override + public GuessRange narrowRange(GuessRange guessRange, GuessValue guessValue) { + GuessRange downMaxed = guessRange.downMax(guessValue); + return downMaxed.upMin(guessValue); + } + + @Override + public boolean isValid(int gap) { + return gap == 0; + } + + @Override + public boolean isContinue() { + return false; + } +} diff --git a/src/main/java/leets/land/domain/status/Down.java b/src/main/java/leets/land/domain/status/Down.java new file mode 100644 index 0000000..d3ad397 --- /dev/null +++ b/src/main/java/leets/land/domain/status/Down.java @@ -0,0 +1,22 @@ +package leets.land.domain.status; + +import leets.land.domain.guess.GuessRange; +import leets.land.domain.guess.GuessValue; + +public class Down implements Status { + + @Override + public GuessRange narrowRange(GuessRange guessRange, GuessValue guessValue) { + return guessRange.downMax(guessValue); + } + + @Override + public boolean isValid(int gap) { + return gap < 0; + } + + @Override + public boolean isContinue() { + return true; + } +} diff --git a/src/main/java/leets/land/domain/status/GuessStatus.java b/src/main/java/leets/land/domain/status/GuessStatus.java new file mode 100644 index 0000000..3073e6b --- /dev/null +++ b/src/main/java/leets/land/domain/status/GuessStatus.java @@ -0,0 +1,34 @@ +package leets.land.domain.status; + +import leets.land.domain.guess.GuessRange; +import leets.land.domain.guess.GuessValue; + +import java.util.Arrays; + +public enum GuessStatus { + + UP(new Up()), + DOWN(new Down()), + CORRECT(new Correct()); + + private final Status status; + + GuessStatus(Status status) { + this.status = status; + } + + public static GuessStatus match(int gap) { + return Arrays.stream(values()) + .filter(status -> status.status.isValid(gap)) + .findFirst() + .orElseThrow(); + } + + public GuessRange narrowRange(GuessValue guessValue, GuessRange guessRange) { + return status.narrowRange(guessRange, guessValue); + } + + public boolean isContinue() { + return status.isContinue(); + } +} diff --git a/src/main/java/leets/land/domain/status/Status.java b/src/main/java/leets/land/domain/status/Status.java new file mode 100644 index 0000000..9a9002a --- /dev/null +++ b/src/main/java/leets/land/domain/status/Status.java @@ -0,0 +1,13 @@ +package leets.land.domain.status; + +import leets.land.domain.guess.GuessRange; +import leets.land.domain.guess.GuessValue; + +public interface Status { + + GuessRange narrowRange(GuessRange guessRange, GuessValue guessValue); + + boolean isValid(int gap); + + boolean isContinue(); +} diff --git a/src/main/java/leets/land/domain/status/Up.java b/src/main/java/leets/land/domain/status/Up.java new file mode 100644 index 0000000..38fbd88 --- /dev/null +++ b/src/main/java/leets/land/domain/status/Up.java @@ -0,0 +1,22 @@ +package leets.land.domain.status; + +import leets.land.domain.guess.GuessRange; +import leets.land.domain.guess.GuessValue; + +public class Up implements Status { + + @Override + public GuessRange narrowRange(GuessRange guessRange, GuessValue guessValue) { + return guessRange.upMin(guessValue); + } + + @Override + public boolean isValid(int gap) { + return gap > 0; + } + + @Override + public boolean isContinue() { + return true; + } +} diff --git a/src/main/java/leets/land/domain/updowngame/AlphabetUpDownGame.java b/src/main/java/leets/land/domain/updowngame/AlphabetUpDownGame.java new file mode 100644 index 0000000..69a67b9 --- /dev/null +++ b/src/main/java/leets/land/domain/updowngame/AlphabetUpDownGame.java @@ -0,0 +1,25 @@ +package leets.land.domain.updowngame; + +import leets.land.domain.AnswerNumber; +import leets.land.domain.guess.GuessAlphabet; +import leets.land.domain.guess.GuessRange; +import leets.land.domain.guess.GuessValue; +import leets.land.domain.status.GuessStatus; + +public class AlphabetUpDownGame implements UpDownGame { + + private final AnswerNumber answerNumber = new RandomAlphabetGenerator().generate(); + private GuessRange guessRange = new GuessRange(new GuessAlphabet('A'), new GuessAlphabet('z')); + + @Override + public GuessStatus play(GuessValue guessValue) { + GuessStatus guessStatus = answerNumber.compare(guessValue); + guessRange = guessStatus.narrowRange(guessValue, guessRange); + return guessStatus; + } + + @Override + public GuessRange guessRange() { + return guessRange; + } +} diff --git a/src/main/java/leets/land/domain/updowngame/NumberUpDownGame.java b/src/main/java/leets/land/domain/updowngame/NumberUpDownGame.java new file mode 100644 index 0000000..fef4f20 --- /dev/null +++ b/src/main/java/leets/land/domain/updowngame/NumberUpDownGame.java @@ -0,0 +1,25 @@ +package leets.land.domain.updowngame; + +import leets.land.domain.AnswerNumber; +import leets.land.domain.guess.GuessNumber; +import leets.land.domain.guess.GuessRange; +import leets.land.domain.guess.GuessValue; +import leets.land.domain.status.GuessStatus; + +public class NumberUpDownGame implements UpDownGame { + + private final AnswerNumber answerNumber = new RandomNumberGenerator().generate(); + private GuessRange guessRange = new GuessRange(new GuessNumber(1), new GuessNumber(100)); + + @Override + public GuessStatus play(GuessValue guessValue) { + GuessStatus guessStatus = answerNumber.compare(guessValue); + guessRange = guessStatus.narrowRange(guessValue, guessRange); + return guessStatus; + } + + @Override + public GuessRange guessRange() { + return guessRange; + } +} diff --git a/src/main/java/leets/land/domain/updowngame/RandomAlphabetGenerator.java b/src/main/java/leets/land/domain/updowngame/RandomAlphabetGenerator.java new file mode 100644 index 0000000..a92d0c0 --- /dev/null +++ b/src/main/java/leets/land/domain/updowngame/RandomAlphabetGenerator.java @@ -0,0 +1,22 @@ +package leets.land.domain.updowngame; + +import leets.land.domain.AnswerNumber; + +import java.util.Random; + +public class RandomAlphabetGenerator { + + private static final int CAPITAL_ORIGIN_RANDOM = 'A'; + private static final int CAPITAL_BOUND_RANDOM = 'Z'; + + private final Random random = new Random(); + + public AnswerNumber generate() { + int randomNumber = random.nextInt(CAPITAL_ORIGIN_RANDOM, CAPITAL_BOUND_RANDOM); + boolean isSmall = random.nextBoolean(); + if (isSmall) { + randomNumber = Character.toLowerCase(randomNumber); + } + return new AnswerNumber(randomNumber); + } +} diff --git a/src/main/java/leets/land/domain/updowngame/RandomNumberGenerator.java b/src/main/java/leets/land/domain/updowngame/RandomNumberGenerator.java new file mode 100644 index 0000000..fe3e95f --- /dev/null +++ b/src/main/java/leets/land/domain/updowngame/RandomNumberGenerator.java @@ -0,0 +1,18 @@ +package leets.land.domain.updowngame; + +import leets.land.domain.AnswerNumber; + +import java.util.Random; + +public class RandomNumberGenerator { + + private static final int ORIGIN_RANDOM = 1; + private static final int BOUND_RANDOM = 101; + + private final Random random = new Random(); + + public AnswerNumber generate() { + int randomNumber = random.nextInt(ORIGIN_RANDOM, BOUND_RANDOM); + return new AnswerNumber(randomNumber); + } +} diff --git a/src/main/java/leets/land/domain/updowngame/UpDownGame.java b/src/main/java/leets/land/domain/updowngame/UpDownGame.java new file mode 100644 index 0000000..28b5412 --- /dev/null +++ b/src/main/java/leets/land/domain/updowngame/UpDownGame.java @@ -0,0 +1,12 @@ +package leets.land.domain.updowngame; + +import leets.land.domain.guess.GuessRange; +import leets.land.domain.guess.GuessValue; +import leets.land.domain.status.GuessStatus; + +public interface UpDownGame { + + GuessStatus play(GuessValue guessValue); + + GuessRange guessRange(); +} diff --git a/src/main/java/leets/land/view/InputView.java b/src/main/java/leets/land/view/InputView.java new file mode 100644 index 0000000..7f1168d --- /dev/null +++ b/src/main/java/leets/land/view/InputView.java @@ -0,0 +1,43 @@ +package leets.land.view; + +import java.util.Scanner; +import java.util.regex.Pattern; + +public class InputView { + + private static final String VERSION_FORMAT = "버전을 입력해주세요 (숫자 버전: 1, 영어 버전: 2) : "; + private static final String GUESS_NUMBER_FORMAT = "숫자를 입력해주세요(%d ~ %d) : "; + private static final String GUESS_ALPHABET_FORMAT = "영어를 입력해주세요(%c ~ %c) : "; + private static final Pattern ALPHABET_FORMAT = Pattern.compile("[A-Z|a-z]"); + private static final Pattern VERSION = Pattern.compile("[1|2]"); + + private final Scanner scanner = new Scanner(System.in); + + public int readGuessNumberInRange(int start, int end) { + System.out.print(String.format(GUESS_NUMBER_FORMAT, start, end)); + try { + return Integer.parseInt(scanner.nextLine()); + } catch (NumberFormatException e) { + System.out.println("[ERROR] 입력 문자의 타입이 맞지 않습니다."); + return readGuessNumberInRange(start, end); + } + } + + public int readGuessAlphabetInRange(int start, int end) { + System.out.print(String.format(GUESS_ALPHABET_FORMAT, start, end)); + String input = scanner.nextLine(); + if (!ALPHABET_FORMAT.matcher(input).matches()) { + throw new IllegalArgumentException("[ERROR] 범위 내의 알파벳을 입력하세요."); + } + return input.charAt(0); + } + + public int readGameVersion() { + System.out.print(VERSION_FORMAT); + String version = scanner.nextLine(); + if (!VERSION.matcher(version).matches()) { + throw new IllegalArgumentException("[ERROR] 존재하지 않는 버전입니다."); + } + return Integer.parseInt(version); + } +} diff --git a/src/main/java/leets/land/view/OutputView.java b/src/main/java/leets/land/view/OutputView.java new file mode 100644 index 0000000..c47995a --- /dev/null +++ b/src/main/java/leets/land/view/OutputView.java @@ -0,0 +1,10 @@ +package leets.land.view; + +import leets.land.domain.status.GuessStatus; + +public class OutputView { + + public void printGuessStatus(GuessStatus guessStatus) { + System.out.println(guessStatus); + } +} diff --git a/src/test/java/leets/land/domain/AnswerNumberTest.java b/src/test/java/leets/land/domain/AnswerNumberTest.java new file mode 100644 index 0000000..234192d --- /dev/null +++ b/src/test/java/leets/land/domain/AnswerNumberTest.java @@ -0,0 +1,45 @@ +package leets.land.domain; + +import leets.land.domain.guess.GuessNumber; +import leets.land.domain.status.GuessStatus; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static leets.land.domain.status.GuessStatus.*; +import static org.assertj.core.api.Assertions.assertThat; + +public class AnswerNumberTest { + + @Test + @DisplayName("추측값이 정답과 일치하면 CORRECT를 반환한다.") + void answer_Grade_Correct() { + GuessNumber guessNumber = new GuessNumber(50); + AnswerNumber answerNumber = new AnswerNumber(50); + + GuessStatus guessStatus = answerNumber.compare(guessNumber); + + assertThat(guessStatus).isEqualTo(CORRECT); + } + + @Test + @DisplayName("추측값이 정답보다 크다면 DOWN을 반환한다.") + void answer_Grade_Down() { + GuessNumber guessNumber = new GuessNumber(51); + AnswerNumber answerNumber = new AnswerNumber(50); + + GuessStatus guessStatus = answerNumber.compare(guessNumber); + + assertThat(guessStatus).isEqualTo(DOWN); + } + + @Test + @DisplayName("추측값이 정답보다 작으면 UP을 반환한다.") + void answer_Grade_Up() { + GuessNumber guessNumber = new GuessNumber(49); + AnswerNumber answerNumber = new AnswerNumber(50); + + GuessStatus guessStatus = answerNumber.compare(guessNumber); + + assertThat(guessStatus).isEqualTo(UP); + } +} diff --git a/src/test/java/leets/land/domain/GuessNumberTest.java b/src/test/java/leets/land/domain/GuessNumberTest.java new file mode 100644 index 0000000..bbf4a2e --- /dev/null +++ b/src/test/java/leets/land/domain/GuessNumberTest.java @@ -0,0 +1,19 @@ +package leets.land.domain; + +import leets.land.domain.guess.GuessNumber; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; + +public class GuessNumberTest { + + @ParameterizedTest + @ValueSource(ints = {0, 101}) + @DisplayName("범위 외 추측값인 경우 예외가 발생한다.") + void guessNumber_OutOfRange_ExceptionThrown(int outOfRange) { + assertThatIllegalArgumentException(). + isThrownBy(() -> new GuessNumber(outOfRange)); + } +} diff --git a/src/test/java/leets/land/domain/GuessRangeTest.java b/src/test/java/leets/land/domain/GuessRangeTest.java new file mode 100644 index 0000000..e4febb5 --- /dev/null +++ b/src/test/java/leets/land/domain/GuessRangeTest.java @@ -0,0 +1,33 @@ +package leets.land.domain; + +import leets.land.domain.guess.GuessNumber; +import leets.land.domain.guess.GuessRange; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +class GuessRangeTest { + + @Test + @DisplayName("상한값을 낮춘다") + void downMax() { + GuessRange guessRange = new GuessRange(new GuessNumber(1), new GuessNumber(100)); + GuessNumber max = new GuessNumber(50); + + GuessRange downedMax = guessRange.downMax(max); + + assertThat(downedMax).isEqualTo(new GuessRange(new GuessNumber(1), max)); + } + + @Test + @DisplayName("하한값을 높인다") + void upMin() { + GuessRange guessRange = new GuessRange(new GuessNumber(1), new GuessNumber(100)); + GuessNumber min = new GuessNumber(50); + + GuessRange downedMax = guessRange.upMin(min); + + assertThat(downedMax).isEqualTo(new GuessRange(min, new GuessNumber(100))); + } +} diff --git a/src/test/java/leets/land/domain/GuessStatusTest.java b/src/test/java/leets/land/domain/GuessStatusTest.java new file mode 100644 index 0000000..9766be0 --- /dev/null +++ b/src/test/java/leets/land/domain/GuessStatusTest.java @@ -0,0 +1,35 @@ +package leets.land.domain; + +import leets.land.domain.status.GuessStatus; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static leets.land.domain.status.GuessStatus.*; +import static org.assertj.core.api.Assertions.assertThat; + +class GuessStatusTest { + + @Test + @DisplayName("차가 양수라면 Up을 반환한다.") + void match_Positive_Up() { + GuessStatus guessStatus = GuessStatus.match(1); + + assertThat(guessStatus).isEqualTo(UP); + } + + @Test + @DisplayName("차가 음수라면 Down을 반환한다.") + void match_Negative_Up() { + GuessStatus guessStatus = GuessStatus.match(-1); + + assertThat(guessStatus).isEqualTo(DOWN); + } + + @Test + @DisplayName("차가 0이라면 Correct을 반환한다.") + void match_Zero_Correct() { + GuessStatus guessStatus = GuessStatus.match(0); + + assertThat(guessStatus).isEqualTo(CORRECT); + } +}