diff --git a/src/main/java/calculator/controller/StringCalculatorApp.java b/src/main/java/calculator/controller/StringCalculatorApp.java new file mode 100644 index 0000000..4e60a94 --- /dev/null +++ b/src/main/java/calculator/controller/StringCalculatorApp.java @@ -0,0 +1,21 @@ +package calculator.controller; + +import calculator.model.Calculator; +import calculator.model.StringReader; +import calculator.view.Input; +import calculator.view.Result; + +public class StringCalculatorApp { + public static void main(String[] args) { + Result.showStartMessage(); + String userInput = Input.getUserInput(); + + System.out.println(userInput); + + StringReader stringReader = new StringReader(); + int[] arr = stringReader.read(userInput); + + Calculator calculator = new Calculator(arr); + Result.showResult(calculator.executeAddition()); + } +} diff --git a/src/main/java/calculator/model/Calculator.java b/src/main/java/calculator/model/Calculator.java new file mode 100644 index 0000000..f7fc0df --- /dev/null +++ b/src/main/java/calculator/model/Calculator.java @@ -0,0 +1,24 @@ +package calculator.model; + +import java.util.Arrays; + +public class Calculator { + private final int result; + + public Calculator(int[] numbers) { + int minusCount = Arrays.stream(numbers).filter(v -> v < 0).toArray().length; + if (minusCount > 0) { + throw new RuntimeException(); + } + + this.result = Arrays.stream(numbers).reduce(Integer::sum).orElse(0); + } + + public static Calculator newCalculator(int[] numbers) { + return new Calculator(numbers); + } + + public int executeAddition() { + return this.result; + } +} diff --git a/src/main/java/calculator/model/StringReader.java b/src/main/java/calculator/model/StringReader.java new file mode 100644 index 0000000..d0fe7d6 --- /dev/null +++ b/src/main/java/calculator/model/StringReader.java @@ -0,0 +1,27 @@ +package calculator.model; + +import java.util.Arrays; + +public class StringReader { + public int[] read(String str) { + String[] arr = str.split("n"); + + return arr.length == 1 + ? withNoCustomSeparator(arr[0]) + : withCustomSeparator(arr[0], arr[1]); + } + + private int[] withNoCustomSeparator(String str) { + String[] numbers = str.split("[:,]"); + + return Arrays.stream(numbers).mapToInt(Integer::parseInt).toArray(); + } + + private int[] withCustomSeparator(String separatorPart, String numberPart) { + String customSeparator = Character.toString(separatorPart.charAt(2)); + String regex = "[:," + customSeparator + "]"; + String[] numbers = numberPart.split(regex); + + return Arrays.stream(numbers).mapToInt(Integer::parseInt).toArray(); + } +} diff --git a/src/main/java/calculator/view/Input.java b/src/main/java/calculator/view/Input.java new file mode 100644 index 0000000..90622e3 --- /dev/null +++ b/src/main/java/calculator/view/Input.java @@ -0,0 +1,11 @@ +package calculator.view; + +import java.util.Scanner; + +public class Input { + + public static String getUserInput() { + Scanner scanner = new Scanner(System.in); + return scanner.nextLine(); + } +} diff --git a/src/main/java/calculator/view/Result.java b/src/main/java/calculator/view/Result.java new file mode 100644 index 0000000..5c9a8dd --- /dev/null +++ b/src/main/java/calculator/view/Result.java @@ -0,0 +1,12 @@ +package calculator.view; + +public class Result { + + public static void showStartMessage() { + System.out.println("숫자들을 입력해주세요"); + } + + public static void showResult(int result) { + System.out.printf("합계: %d", result); + } +} 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/main/java/lotto/controller/LottoApplication.java b/src/main/java/lotto/controller/LottoApplication.java new file mode 100644 index 0000000..54d893d --- /dev/null +++ b/src/main/java/lotto/controller/LottoApplication.java @@ -0,0 +1,42 @@ +package lotto.controller; + +import lotto.domain.*; +import lotto.view.Input; +import lotto.view.Output; + +import java.util.List; + +public class LottoApplication { + public static void main(String[] args) { + Money money; + try { + money = Money.newMoney(Input.getUserInputMoney()); + } catch (IllegalArgumentException e) { + Output.showErrorMessage(e); + money = Money.newMoney(1000); + } + + ManualLottoTicketWriter manualWriter = ManualLottoTicketWriter.newWriter(); + List manualTickets = manualWriter.write(Input.getUserInputManualCount()); + + LottoMachine lottoMachine = LottoMachine.newMachine(); + lottoMachine.makeTickets(money, manualTickets); + + Output.showLottoTickets(lottoMachine); + + String winningNumbers = Input.getWinningNumbers(); + + LottoBall lottoBallNumber; + try { + lottoBallNumber = LottoBall.newBall(Input.getBonusBallNumber()); + } catch (IllegalArgumentException e) { + Output.showErrorMessage(e); + lottoBallNumber = LottoBall.newBall(45); + } + + LottoChecker lottoChecker = LottoChecker.newChecker(winningNumbers, lottoBallNumber); + CheckCounter counter = lottoChecker.checkAllTickets(lottoMachine); + + Output.showResult(counter, money); + } +} diff --git a/src/main/java/lotto/controller/ManualLottoTicketWriter.java b/src/main/java/lotto/controller/ManualLottoTicketWriter.java new file mode 100644 index 0000000..e8b1c0a --- /dev/null +++ b/src/main/java/lotto/controller/ManualLottoTicketWriter.java @@ -0,0 +1,39 @@ +package lotto.controller; + +import lotto.domain.LottoBall; +import lotto.domain.LottoTicket; +import lotto.view.Input; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +public class ManualLottoTicketWriter { + + public ManualLottoTicketWriter() {} + + public static ManualLottoTicketWriter newWriter() { + return new ManualLottoTicketWriter(); + } + + public List write(int manualLottoCount) { + ArrayList manualTickets = new ArrayList<>(); + + for (int i = 0; i < manualLottoCount; i += 1) { + String numberString = Input.getManualLottoNumber(); + LottoTicket ticket = convertToLottoTickets(numberString); + + manualTickets.add(ticket); + } + + return manualTickets; + } + + private LottoTicket convertToLottoTickets(String numberString) { + int[] numbers = Arrays.stream(numberString.split(",")).mapToInt(Integer::parseInt).toArray(); + List lottoNumbers = Arrays.stream(numbers).mapToObj(LottoBall::newBall).collect(Collectors.toList()); + + return LottoTicket.newTicket(lottoNumbers); + } +} diff --git a/src/main/java/lotto/domain/CheckCounter.java b/src/main/java/lotto/domain/CheckCounter.java new file mode 100644 index 0000000..6d2910d --- /dev/null +++ b/src/main/java/lotto/domain/CheckCounter.java @@ -0,0 +1,36 @@ +package lotto.domain; + +import java.util.Map; +import java.util.TreeMap; + +public class CheckCounter { + private final Map checkCounter; + + public CheckCounter() { + this.checkCounter = new TreeMap<>(); + } + + public void setInitial(int key) { + this.checkCounter.put(key, 1); + } + + public int get(int key) { + return this.checkCounter.getOrDefault(key, 0); + } + + public boolean has(int key) { + return this.checkCounter.containsKey(key); + } + + public void countUp(int key) { + int previousValue = this.checkCounter.get(key); + this.checkCounter.put(key, previousValue + 1); + } + + public int getTotalWinningMoney() { + return (5_000 * this.checkCounter.getOrDefault(3, 0)) + + (50_000 * this.checkCounter.getOrDefault(4, 0)) + + (1_500_000 * this.checkCounter.getOrDefault(5, 0)) + + (2_000_000_000 * this.checkCounter.getOrDefault(6, 0)); + } +} diff --git a/src/main/java/lotto/domain/LottoBall.java b/src/main/java/lotto/domain/LottoBall.java new file mode 100644 index 0000000..95e1423 --- /dev/null +++ b/src/main/java/lotto/domain/LottoBall.java @@ -0,0 +1,48 @@ +package lotto.domain; + +import java.util.List; + +public class LottoBall implements Comparable{ + + private final int ballNumber; + + public LottoBall(int number) { + this.validate(number); + this.ballNumber = number; + } + + public static LottoBall newBall(int number) { + return new LottoBall(number); + } + + private void validate(int number) { + if (number < 1 || number > 45) { + throw new IllegalArgumentException("보너스 볼로 가능한 숫자는 1 ~ 45 입니다."); + } + } + + @Override + public int compareTo(Object obj) { + LottoBall next = (LottoBall) obj; + return this.ballNumber - next.ballNumber; + } + + @Override + public boolean equals(Object obj) { + LottoBall next = (LottoBall) obj; + return this.ballNumber == next.ballNumber; + } + + public boolean isElementOf(List numbers) { + return numbers.contains(this.ballNumber); + } + + public boolean isSameWith(int number) { + return number == this.ballNumber; + } + + @Override + public String toString() { + return this.ballNumber + ""; + } +} diff --git a/src/main/java/lotto/domain/LottoChecker.java b/src/main/java/lotto/domain/LottoChecker.java new file mode 100644 index 0000000..9084bab --- /dev/null +++ b/src/main/java/lotto/domain/LottoChecker.java @@ -0,0 +1,64 @@ +package lotto.domain; + +import java.util.Arrays; +import java.util.List; + +public class LottoChecker { + + private final CheckCounter checkCounter = new CheckCounter(); + private final List winningNumbers; + private final LottoBall bonusBall; + + public LottoChecker(String winnings, LottoBall bonusBall) { + this.winningNumbers = convertToList(winnings); + this.bonusBall = bonusBall; + } + + public static LottoChecker newChecker(String winnings, LottoBall bonusBall) { + return new LottoChecker(winnings, bonusBall); + } + + public CheckCounter checkAllTickets(LottoMachine lottoMachine) { + List tickets = lottoMachine.getTickets(); + for (LottoTicket ticket : tickets) { + int matchCount = ticket.countMatchedNumber(this.winningNumbers); + boolean bonusBallMatch = isContainingBonusBall(ticket); + + executeCheckCounter(matchCount, bonusBallMatch); + } + + return this.checkCounter; + } + + private void executeCheckCounter(int matchCount, boolean bonusBallMatch) { + if (matchCount == 5 && bonusBallMatch) { + int secondWinner = 7; + addToCheckCounter(secondWinner); + return; + } + + addToCheckCounter(matchCount); + } + + private void addToCheckCounter(int matchCount) { + if (this.checkCounter.has(matchCount)) { + this.checkCounter.countUp(matchCount); + return; + } + + this.checkCounter.setInitial(matchCount); + } + + private List convertToList(String string) { + return Arrays.asList( + Arrays.stream(string.split(",")) + .mapToInt(Integer::parseInt) + .boxed() + .toArray(Integer[]::new) + ); + } + + private boolean isContainingBonusBall(LottoTicket ticket) { + return ticket.isContaining(this.bonusBall); + } +} diff --git a/src/main/java/lotto/domain/LottoMachine.java b/src/main/java/lotto/domain/LottoMachine.java new file mode 100644 index 0000000..38e2e29 --- /dev/null +++ b/src/main/java/lotto/domain/LottoMachine.java @@ -0,0 +1,43 @@ +package lotto.domain; + +import java.util.ArrayList; +import java.util.List; + +public class LottoMachine { + + private final List lottoTickets = new ArrayList<>(); + + public LottoMachine() {} + + public static LottoMachine newMachine() { + return new LottoMachine(); + } + + public List getTickets() { + return this.lottoTickets; + } + + public void makeTicket(List numbers) { + LottoTicket newTicket = LottoTicket.newTicket(numbers); + this.lottoTickets.add(newTicket); + } + + public void makeTickets(Money money, List manualTickets) { + int manualLottoCount = manualTickets.size(); + int autoLottoCount = money.getAutoLottoCount(manualLottoCount); + + makeAutoLottos(autoLottoCount); + makeManualLottos(manualTickets); + } + + private void makeAutoLottos(int autoLottoCount) { + for (int i = 0; i < autoLottoCount; i += 1) { + List randomNumbers = RandomGenerator.newGenerator().getNumbers(); + this.makeTicket(randomNumbers); + } + } + + private void makeManualLottos(List manualTickets) { + this.lottoTickets.addAll(manualTickets); + } +} diff --git a/src/main/java/lotto/domain/LottoTicket.java b/src/main/java/lotto/domain/LottoTicket.java new file mode 100644 index 0000000..f43776f --- /dev/null +++ b/src/main/java/lotto/domain/LottoTicket.java @@ -0,0 +1,55 @@ +package lotto.domain; + +import java.util.List; + +public class LottoTicket { + + private final List lottoNumbers; + + public LottoTicket(List numbers) { + this.lottoNumbers = numbers; + } + + public static LottoTicket newTicket(List numbers) { + return new LottoTicket(numbers); + } + + public int countMatchedNumber(List winningNumbers) { + int count = 0; + for (Integer number : winningNumbers) { + count = plusCount(this.lottoNumbers, count, number); + } + + return count; + } + + private int plusCount(List ticketNumbers, int count, Integer number) { + for (LottoBall ball : ticketNumbers) { + count = addCount(count, number, ball); + } + + return count; + } + + private int addCount(int count, Integer number, LottoBall ball) { + if (ball.isSameWith(number)) { + count += 1; + } + + return count; + } + + public boolean isContaining(LottoBall ball) { + return this.lottoNumbers.contains(ball); + } + + @Override + public String toString() { + String result = ""; + for (LottoBall ball : this.lottoNumbers) { + result += ball.toString() + " "; + } + + return "[ " + result + "]"; + } +} \ No newline at end of file diff --git a/src/main/java/lotto/domain/Money.java b/src/main/java/lotto/domain/Money.java new file mode 100644 index 0000000..2d2deb6 --- /dev/null +++ b/src/main/java/lotto/domain/Money.java @@ -0,0 +1,29 @@ +package lotto.domain; + +public class Money { + + private final int money; + + public Money(int money) { + this.validate(money); + this.money = money; + } + + public static Money newMoney(int money) { + return new Money(money); + } + + private void validate(int money) { + if (money < 1000) { + throw new IllegalArgumentException("1000원 이상 구매하셔야 합니다."); + } + } + + public int getAutoLottoCount(int manualLottoCount) { + return (this.money / 1000) - manualLottoCount; + } + + public double getRevenueRate(int totalWinningMoney) { + return (double) totalWinningMoney / this.money; + } +} diff --git a/src/main/java/lotto/domain/RandomGenerator.java b/src/main/java/lotto/domain/RandomGenerator.java new file mode 100644 index 0000000..c64d604 --- /dev/null +++ b/src/main/java/lotto/domain/RandomGenerator.java @@ -0,0 +1,29 @@ +package lotto.domain; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class RandomGenerator { + + private final List numbers; + + public RandomGenerator() { + this.numbers = new ArrayList<>(); + for (int i = 1; i <= 45; i += 1) { + numbers.add(LottoBall.newBall(i)); + } + } + + public static RandomGenerator newGenerator() { + return new RandomGenerator(); + } + + public List getNumbers() { + Collections.shuffle(numbers); + List sevenNumbers = numbers.subList(0, 7); + Collections.sort(sevenNumbers); + + return sevenNumbers; + } +} diff --git a/src/main/java/lotto/view/Input.java b/src/main/java/lotto/view/Input.java new file mode 100644 index 0000000..cd45bb1 --- /dev/null +++ b/src/main/java/lotto/view/Input.java @@ -0,0 +1,43 @@ +package lotto.view; + +import java.util.Scanner; + +public class Input { + public static int getUserInputMoney() { + System.out.println("로또 구입 금액을 입력해주세요."); + Scanner scanner = new Scanner(System.in); + + int money = scanner.nextInt(); + System.out.printf("%d개를 구매하셨습니다.\n", money / 1000); + + return money; + } + + public static int getUserInputManualCount() { + System.out.println("수동으로 구매할 로또의 수를 입력해주세요"); + Scanner scanner = new Scanner(System.in); + + return scanner.nextInt(); + } + + public static String getManualLottoNumber() { + System.out.println("수동으로 구매할 로또의 번호를 입력해주세요"); + Scanner scanner = new Scanner(System.in); + + return scanner.nextLine(); + } + + public static String getWinningNumbers() { + System.out.println("당첨 번호를 입력해주세요."); + Scanner scanner = new Scanner(System.in); + + return scanner.nextLine(); + } + + public static int getBonusBallNumber() { + System.out.println("보너스 볼을 입력해주세요."); + Scanner scanner = new Scanner(System.in); + + return scanner.nextInt(); + } +} diff --git a/src/main/java/lotto/view/Output.java b/src/main/java/lotto/view/Output.java new file mode 100644 index 0000000..59a36ed --- /dev/null +++ b/src/main/java/lotto/view/Output.java @@ -0,0 +1,70 @@ +package lotto.view; + +import lotto.domain.CheckCounter; +import lotto.domain.LottoMachine; +import lotto.domain.LottoTicket; +import lotto.domain.Money; + +import java.util.List; + +public class Output { + public static void showLottoTickets(LottoMachine lottoMachine) { + System.out.println(""); + List tickets = lottoMachine.getTickets(); + tickets.forEach(ticket -> System.out.println(ticket.toString())); + } + + public enum ShowWinner { + FIRST { + @Override + public void showCount(CheckCounter counter) { + System.out.printf("모두 일치 (2,000,000,000원) - %d개\n", counter.get(6)); + } + }, + SECOND { + @Override + public void showCount(CheckCounter counter) { + System.out.printf("5개 일치, 보너스 볼 일치(30_000_000원) - %d개\n", counter.get(7)); + } + }, + THIRD { + @Override + public void showCount(CheckCounter counter) { + System.out.printf("5개 일치 (1,500,000원) - %d개\n", counter.get(5)); + } + }, + FOURTH { + @Override + public void showCount(CheckCounter counter) { + System.out.printf("4개 일치 (50,000원) - %d개\n", counter.get(4)); + } + }, + FIFTH { + @Override + public void showCount(CheckCounter counter) { + System.out.printf("3개 일치 (5,000원) - %d개\n", counter.get(3)); + } + }; + + abstract public void showCount(CheckCounter counter); + } + + public static void showResult(CheckCounter counter, Money money) { + System.out.println(""); + System.out.println("당첨 통계"); + System.out.println("----------------------------"); + ShowWinner.FIFTH.showCount(counter); + ShowWinner.FOURTH.showCount(counter); + ShowWinner.THIRD.showCount(counter); + ShowWinner.SECOND.showCount(counter); + ShowWinner.FIRST.showCount(counter); + System.out.println(""); + + System.out.printf("총 수익률은 %.2f입니다.\n\n\n", money.getRevenueRate(counter.getTotalWinningMoney())); + } + + public static void showErrorMessage(IllegalArgumentException e) { + System.out.println(""); + System.out.println(e.getMessage()); + } +} diff --git a/src/test/java/calculator/CalculatorTest.java b/src/test/java/calculator/CalculatorTest.java new file mode 100644 index 0000000..d5f3278 --- /dev/null +++ b/src/test/java/calculator/CalculatorTest.java @@ -0,0 +1,46 @@ +package calculator; + +import calculator.model.Calculator; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +public class CalculatorTest { + @Test + @DisplayName("with zero parameter") + public void nullParameter() { + Calculator calculator = Calculator.newCalculator(new int[] { 0 }); + + int answer = calculator.executeAddition(); + + assertThat(answer).isEqualTo(0); + } + + @Test + @DisplayName("with only one number parameter") + public void oneParameter() { + Calculator calculator = Calculator.newCalculator(new int[] { 3 }); + + int answer = calculator.executeAddition(); + + assertThat(answer).isEqualTo(3); + } + + @Test + @DisplayName("with array parameter") + public void arrayParameter() { + Calculator calculator = Calculator.newCalculator(new int[] { 1, 2, 3, 4 }); + + int answer = calculator.executeAddition(); + + assertThat(answer).isEqualTo(10); + } + + @Test + @DisplayName("with minus parameter") + public void minusParameter() { + assertThatThrownBy(() -> Calculator.newCalculator(new int[] { -5 })).isInstanceOf(RuntimeException.class); + } +} diff --git a/src/test/java/calculator/StringReaderTest.java b/src/test/java/calculator/StringReaderTest.java new file mode 100644 index 0000000..5e642fb --- /dev/null +++ b/src/test/java/calculator/StringReaderTest.java @@ -0,0 +1,36 @@ +package calculator; + +import calculator.model.StringReader; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class StringReaderTest { + + StringReader stringReader; + + @BeforeEach + void init() { + stringReader = new StringReader(); + } + + @Test + @DisplayName("with multiple numbers parameter") + public void multipleNumbers() { + assertThat(stringReader.read("1,2,3,4")).isEqualTo(new int[] { 1, 2, 3, 4 }); + } + + @Test + @DisplayName("with only one number parameter") + public void onlyOneNumber() { + assertThat(stringReader.read("5")).isEqualTo(new int[] { 5 }); + } + + @Test + @DisplayName("with custom separator") + public void withSeparator() { + assertThat(stringReader.read("//;\\n1:2;3,4")).isEqualTo(new int[] { 1, 2, 3, 4 }); + } +} diff --git a/src/test/java/empty.txt b/src/test/java/empty.txt deleted file mode 100644 index e69de29..0000000 diff --git a/src/test/java/lotto/CheckCounterTest.java b/src/test/java/lotto/CheckCounterTest.java new file mode 100644 index 0000000..d1e422d --- /dev/null +++ b/src/test/java/lotto/CheckCounterTest.java @@ -0,0 +1,47 @@ +package lotto; + +import lotto.domain.CheckCounter; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class CheckCounterTest { + @Test + void put() { + CheckCounter checkCounter = new CheckCounter(); + + checkCounter.setInitial(1); + + assertThat(checkCounter.get(1)).isEqualTo(1); + } + + @Test + void has() { + CheckCounter checkCounter = new CheckCounter(); + + checkCounter.setInitial(1); + + assertThat(checkCounter.has(1)).isTrue(); + assertThat(checkCounter.has(2)).isFalse(); + } + + @Test + void countUp() { + CheckCounter checkCounter = new CheckCounter(); + + checkCounter.setInitial(1); + checkCounter.countUp(1); + + assertThat(checkCounter.get(1)).isEqualTo(2); + } + + @Test + void getTotalWinningMoney() { + CheckCounter checkCounter = new CheckCounter(); + + checkCounter.setInitial(3); + checkCounter.setInitial(4); + + assertThat(checkCounter.getTotalWinningMoney()).isEqualTo(55_000); + } +} diff --git a/src/test/java/lotto/LottoBallTest.java b/src/test/java/lotto/LottoBallTest.java new file mode 100644 index 0000000..edd9d7f --- /dev/null +++ b/src/test/java/lotto/LottoBallTest.java @@ -0,0 +1,32 @@ +package lotto; + +import lotto.domain.LottoBall; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +public class LottoBallTest { + @ParameterizedTest + @ValueSource(ints = {-1, 46}) + @DisplayName("with invalid bonusBall") + void invalidBonusBall(int number) { + assertThatThrownBy(() -> { + LottoBall lottoBall = LottoBall.newBall(number); + }).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void isElementOf() { + LottoBall lottoBall = LottoBall.newBall(2); + List numbers = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6, 7)); + + assertThat(lottoBall.isElementOf(numbers)).isTrue(); + } +} diff --git a/src/test/java/lotto/LottoCheckerTest.java b/src/test/java/lotto/LottoCheckerTest.java new file mode 100644 index 0000000..a706257 --- /dev/null +++ b/src/test/java/lotto/LottoCheckerTest.java @@ -0,0 +1,78 @@ +package lotto; + +import lotto.domain.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class LottoCheckerTest { + LottoMachine lottoMachine; + LottoChecker lottoChecker; + + @BeforeEach + void init() { + lottoMachine = LottoMachine.newMachine(); + + lottoMachine.makeTicket(List.of( + LottoBall.newBall(1), + LottoBall.newBall(2), + LottoBall.newBall(3), + LottoBall.newBall(11), + LottoBall.newBall(12), + LottoBall.newBall(13), + LottoBall.newBall(14) + )); + lottoMachine.makeTicket(List.of( + LottoBall.newBall(1), + LottoBall.newBall(2), + LottoBall.newBall(11), + LottoBall.newBall(12), + LottoBall.newBall(13), + LottoBall.newBall(14), + LottoBall.newBall(15) + )); + lottoMachine.makeTicket(List.of( + LottoBall.newBall(11), + LottoBall.newBall(12), + LottoBall.newBall(13), + LottoBall.newBall(14), + LottoBall.newBall(15), + LottoBall.newBall(16), + LottoBall.newBall(17) + )); + lottoMachine.makeTicket(List.of( + LottoBall.newBall(1), + LottoBall.newBall(2), + LottoBall.newBall(3), + LottoBall.newBall(4), + LottoBall.newBall(5), + LottoBall.newBall(7), + LottoBall.newBall(16) + )); + + String winningNumbers = "1,2,3,4,5,6"; + LottoBall lottoBall = LottoBall.newBall(7); + lottoChecker = LottoChecker.newChecker(winningNumbers, lottoBall); + } + + @ParameterizedTest + @CsvSource(value = { + "1,0", + "2,1", + "3,1", + "4,0", + "5,0", + "6,0", + "7,1", + }) + void checkAllTickets(Integer key, Integer value) { + CheckCounter checkCounter = lottoChecker.checkAllTickets(lottoMachine); + + assertThat(checkCounter.get(key)).isEqualTo(value); + } +} diff --git a/src/test/java/lotto/LottoMachineTest.java b/src/test/java/lotto/LottoMachineTest.java new file mode 100644 index 0000000..ec7554c --- /dev/null +++ b/src/test/java/lotto/LottoMachineTest.java @@ -0,0 +1,57 @@ +package lotto; + +import lotto.domain.LottoBall; +import lotto.domain.LottoMachine; +import lotto.domain.LottoTicket; +import lotto.domain.Money; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class LottoMachineTest { + @ParameterizedTest + @CsvSource(value = { + "1,true", + "3,true", + "5,true", + "7,true", + "9,true", + "11,true", + "13,true", + "14,false", + "15,false", + }) + void makeLottoTicket(int number, boolean bool) { + LottoMachine lottoMachine = LottoMachine.newMachine(); + List numbers = new ArrayList<>(List.of( + LottoBall.newBall(1), + LottoBall.newBall(3), + LottoBall.newBall(5), + LottoBall.newBall(7), + LottoBall.newBall(9), + LottoBall.newBall(11), + LottoBall.newBall(13) + )); + + lottoMachine.makeTicket(numbers); + + LottoTicket ticket = lottoMachine.getTickets().get(0); + LottoBall ball = LottoBall.newBall(number); + assertThat(ticket.isContaining(ball)).isEqualTo(bool); + } + + @Test + void makeTickets() { + Money money = Money.newMoney(14_000); + LottoMachine lottoMachine = LottoMachine.newMachine(); + List empty = new ArrayList<>(); + lottoMachine.makeTickets(money, empty); + + assertThat(lottoMachine.getTickets()).hasSize(14); + } +} diff --git a/src/test/java/lotto/LottoTicketTest.java b/src/test/java/lotto/LottoTicketTest.java new file mode 100644 index 0000000..b1dd5d5 --- /dev/null +++ b/src/test/java/lotto/LottoTicketTest.java @@ -0,0 +1,31 @@ +package lotto; + +import lotto.domain.LottoBall; +import lotto.domain.LottoTicket; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class LottoTicketTest { + + @Test + void countMatchedNumber() { + List numbers = new ArrayList<>(List.of( + LottoBall.newBall(1), + LottoBall.newBall(2), + LottoBall.newBall(3), + LottoBall.newBall(4), + LottoBall.newBall(5), + LottoBall.newBall(6), + LottoBall.newBall(7) + )); + + LottoTicket lottoTicket = LottoTicket.newTicket(numbers); + List winningNumbers = new ArrayList<>(List.of(1, 2, 3, 14, 15, 16, 17)); + + assertThat(lottoTicket.countMatchedNumber(winningNumbers)).isEqualTo(3); + } +} diff --git a/src/test/java/lotto/MoneyTest.java b/src/test/java/lotto/MoneyTest.java new file mode 100644 index 0000000..e0de736 --- /dev/null +++ b/src/test/java/lotto/MoneyTest.java @@ -0,0 +1,35 @@ +package lotto; + +import lotto.domain.Money; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +public class MoneyTest { + @Test + void withInvalidMoney() { + assertThatThrownBy(() -> { + Money money = Money.newMoney(900); + }).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void getAutoLottoCount() { + Money money = Money.newMoney(14_000); + + int manualLottoCount = 3; + + assertThat(money.getAutoLottoCount(manualLottoCount)).isEqualTo(11); + } + + @Test + void getRevenueRate() { + Money money = Money.newMoney(14_000); + + int totalWinningMoney = 7_000; + + assertThat(money.getRevenueRate(totalWinningMoney)).isEqualTo(0.5); + } +} diff --git a/src/test/java/lotto/RandomGeneratorTest.java b/src/test/java/lotto/RandomGeneratorTest.java new file mode 100644 index 0000000..977c13e --- /dev/null +++ b/src/test/java/lotto/RandomGeneratorTest.java @@ -0,0 +1,20 @@ +package lotto; + +import lotto.domain.LottoBall; +import lotto.domain.RandomGenerator; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +public class RandomGeneratorTest { + @Test + void getNumbers() { + RandomGenerator randomGenerator = RandomGenerator.newGenerator(); + + List numbers = randomGenerator.getNumbers(); + + assertThat(numbers).hasSize(7); + } +}