diff --git a/src/main/java/Main.java b/src/main/java/Main.java deleted file mode 100644 index 6408411..0000000 --- a/src/main/java/Main.java +++ /dev/null @@ -1,7 +0,0 @@ -public class Main { - - public static void main(String[] args) { - System.out.println("hello, world"); - } - -} diff --git a/src/main/java/lottodomain/Lotto.java b/src/main/java/lottodomain/Lotto.java new file mode 100644 index 0000000..aeb1ff7 --- /dev/null +++ b/src/main/java/lottodomain/Lotto.java @@ -0,0 +1,36 @@ +package lottodomain; + +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +public class Lotto { + private List lottoNos; + + public Lotto(List lottoNos) { + Collections.sort(lottoNos); + this.lottoNos = lottoNos.stream().map(number -> new LottoNo(number)).collect(Collectors.toList()); + } + + public List getLottoNos() { + return lottoNos; + } + + public boolean contains(LottoNo lottoNo) { + return lottoNos.contains(lottoNo); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + Lotto lotto = (Lotto) o; + return Objects.equals(lottoNos, lotto.lottoNos); + } +} + diff --git a/src/main/java/lottodomain/LottoAnalyzer.java b/src/main/java/lottodomain/LottoAnalyzer.java new file mode 100644 index 0000000..2130f92 --- /dev/null +++ b/src/main/java/lottodomain/LottoAnalyzer.java @@ -0,0 +1,42 @@ +package lottodomain; + +import java.util.List; +import java.util.stream.Collectors; + +public class LottoAnalyzer { + private static final int PRICE_PER_LOTTO = 1000; + private static final int PERCENTAGE = 100; + + private List lottos; + private List winningLottos; + + public LottoAnalyzer(List lottos, WinningNos winningNos) { + this.lottos = lottos; + winningLottos = lottos.stream().map(lotto -> new WinningLotto(lotto, calculateRankOfLotto(lotto, winningNos))) + .collect(Collectors.toList()); + } + + public Rank calculateRankOfLotto(Lotto lotto, WinningNos winningNos) { + int countOfMatch = winningNos.countMatchOf(lotto); + boolean matchBonus = winningNos.isBonus(lotto); + return Rank.valueOf(countOfMatch, matchBonus); + } + + public double calculateEarningRate() { + int inputMoney = lottos.size() * PRICE_PER_LOTTO; + double earnedMoney = calculateEarnedMoney(); + return Math.round(earnedMoney / inputMoney * PERCENTAGE * 10) / 10.0; + } + + public int calculateEarnedMoney() { + List winningMoneys = winningLottos.stream() + .map(winningLotto -> winningLotto.getLottoPrize().getWinningMoney()) + .collect(Collectors.toList()); + return winningMoneys.stream().reduce(0, (accumulation, current) -> accumulation + current); + } + + public int countRank(Rank findingRank) { + return (int) winningLottos.stream().map(WinningLotto::getLottoPrize) + .filter(rank -> rank.equals(findingRank)).count(); + } +} diff --git a/src/main/java/lottodomain/LottoGame.java b/src/main/java/lottodomain/LottoGame.java new file mode 100644 index 0000000..9c15648 --- /dev/null +++ b/src/main/java/lottodomain/LottoGame.java @@ -0,0 +1,46 @@ +package lottodomain; + +import java.util.ArrayList; +import java.util.List; + +public class LottoGame { + private static final int PRICE_PER_LOTTO = 1000; + + private List allLotto; + private int numberOfAllLotto; + + public LottoGame(int inputMoney, List> manualLottoNos) { + numberOfAllLotto = inputMoney / PRICE_PER_LOTTO; + allLotto = issueLottos(manualLottoNos); + } + + public LottoAnalyzer getLottoAnalyzer(WinningNos winningNos) { + return new LottoAnalyzer(allLotto, winningNos); + } + + public List getAllLotto() { + return allLotto; + } + + private List issueLottos(List> manualLottoNos) { + List lottos = issueManualLottos(manualLottoNos); + lottos.addAll(issueAutoLottos(numberOfAllLotto - lottos.size())); + return lottos; + } + + private List issueManualLottos(List> manualLottoNos) { + List ManualLottos = new ArrayList<>(); + for (int i = 0; i < manualLottoNos.size(); i++) { + ManualLottos.add(LottoGenerator.generateLottoWithNos(manualLottoNos.get(i))); + } + return ManualLottos; + } + + private List issueAutoLottos(int numberOfAutoLottos) { + List autoLottos = new ArrayList<>(); + for (int i = 0; i < numberOfAutoLottos; i++) { + autoLottos.add(LottoGenerator.generateAutoLotto()); + } + return autoLottos; + } +} diff --git a/src/main/java/lottodomain/LottoGenerator.java b/src/main/java/lottodomain/LottoGenerator.java new file mode 100644 index 0000000..e28d837 --- /dev/null +++ b/src/main/java/lottodomain/LottoGenerator.java @@ -0,0 +1,25 @@ +package lottodomain; + +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +public class LottoGenerator { + private static final List LOTTO_NO_POOLS = IntStream.rangeClosed(1, 45).boxed().collect(Collectors.toList()); + ; + + public static Lotto generateLottoWithNos(List lottoNos) { + return new Lotto(lottoNos); + } + + public static Lotto generateAutoLotto() { + return generateLottoWithNos(getRandomNos()); + } + + + private static List getRandomNos() { + Collections.shuffle(LOTTO_NO_POOLS); + return LOTTO_NO_POOLS.subList(0, 6); + } +} diff --git a/src/main/java/lottodomain/LottoNo.java b/src/main/java/lottodomain/LottoNo.java new file mode 100644 index 0000000..30bc5a8 --- /dev/null +++ b/src/main/java/lottodomain/LottoNo.java @@ -0,0 +1,25 @@ +package lottodomain; + +public class LottoNo { + private Integer value; + + public LottoNo(int number) { + value = number; + } + + public Integer getValue() { + return value; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + LottoNo lottoNo = (LottoNo) o; + return value == lottoNo.value; + } +} diff --git a/src/main/java/lottodomain/Main.java b/src/main/java/lottodomain/Main.java new file mode 100644 index 0000000..3e496b9 --- /dev/null +++ b/src/main/java/lottodomain/Main.java @@ -0,0 +1,28 @@ +package lottodomain; + +import lottoview.InputView; +import lottoview.OutputView; +import java.util.List; +import java.util.Scanner; + +public class Main { + public static void main(String[] args) { + try { + Scanner scanner = new Scanner(System.in); + int payment = InputView.askPayment(scanner); + int numberOfManualLottos = InputView.askNumberOfManualLottos(scanner); + List> manualNumbers = InputView.askManualLottoNos(scanner, numberOfManualLottos); + + LottoGame lottoGame = new LottoGame(payment, manualNumbers); + OutputView.showAllLottos(lottoGame.getAllLotto(), numberOfManualLottos); + + WinningNos winningNos = new WinningNos( + InputView.askWinningNos(scanner), InputView.askBonusNo(scanner) + ); + LottoAnalyzer lottoAnalyzer = lottoGame.getLottoAnalyzer(winningNos); + OutputView.showAnalysis(lottoAnalyzer); + } catch (Exception e) { + e.printStackTrace(); + } + } +} diff --git a/src/main/java/lottodomain/Rank.java b/src/main/java/lottodomain/Rank.java new file mode 100644 index 0000000..0d9437b --- /dev/null +++ b/src/main/java/lottodomain/Rank.java @@ -0,0 +1,44 @@ +package lottodomain; + +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public enum Rank { + FIRST(6, 2000000000), + SECOND(5, 30000000), + THIRD(5, 1500000), + FOURTH(4, 50000), + FIFTH(3, 5000), + MISS(0, 0); + + private int countOfMatch; + private int winningMoney; + + private Rank(int countOfMatch, int winningMoney) { + this.countOfMatch = countOfMatch; + this.winningMoney = winningMoney; + } + + public int getCountOfMatch() { + return countOfMatch; + } + + public int getWinningMoney() { + return winningMoney; + } + + public static Rank valueOf(int countOfMatch, boolean matchBonus) { + if (countOfMatch == 5 && matchBonus) { + return SECOND; + } + Map countOfMatchRankMapWithoutSecond = Stream.of(values()).filter(rank -> rank != SECOND) + .collect(Collectors.toMap(Rank::getCountOfMatch, Function.identity())); + Rank result = countOfMatchRankMapWithoutSecond.get(countOfMatch); + if (result == null) { + result = MISS; + } + return result; + } +} diff --git a/src/main/java/lottodomain/WinningLotto.java b/src/main/java/lottodomain/WinningLotto.java new file mode 100644 index 0000000..0932994 --- /dev/null +++ b/src/main/java/lottodomain/WinningLotto.java @@ -0,0 +1,21 @@ +package lottodomain; + +import java.util.List; + +public class WinningLotto { + private List lottoNos; + private Rank lottoPrize; + + public WinningLotto(Lotto lotto, Rank lottoPrize) { + lottoNos = lotto.getLottoNos(); + this.lottoPrize = lottoPrize; + } + + public List getLottoNos() { + return lottoNos; + } + + public Rank getLottoPrize() { + return lottoPrize; + } +} diff --git a/src/main/java/lottodomain/WinningNos.java b/src/main/java/lottodomain/WinningNos.java new file mode 100644 index 0000000..0bf18ee --- /dev/null +++ b/src/main/java/lottodomain/WinningNos.java @@ -0,0 +1,23 @@ +package lottodomain; + +import java.util.List; +import java.util.stream.Collectors; + +public class WinningNos { + private List winningNos; + private LottoNo bonusNo; + + public WinningNos(List winningNos, int bonusNo) { + this.winningNos = winningNos.stream().map(number -> new LottoNo(number)) + .collect(Collectors.toList()); + this.bonusNo = new LottoNo(bonusNo); + } + + public int countMatchOf(Lotto lotto) { + return winningNos.stream().filter(lotto::contains).collect(Collectors.toList()).size(); + } + + public boolean isBonus(Lotto lotto) { + return lotto.contains(bonusNo); + } +} diff --git a/src/main/java/lottoview/InputValidation.java b/src/main/java/lottoview/InputValidation.java new file mode 100644 index 0000000..00dc04d --- /dev/null +++ b/src/main/java/lottoview/InputValidation.java @@ -0,0 +1,44 @@ +package lottoview; + +import java.util.List; + +public class InputValidation { + private final static int NUMBER_OF_LOTTO_NOS = 6; + private final static int PRICE_PER_LOTTO = 1000; + + public static void validatePayment(int payment) throws ViewException { + if (payment < PRICE_PER_LOTTO) { + throw new ViewException("[ViewException] 구입금액은 1000원 이상이어야 합니다"); + } + if (payment % PRICE_PER_LOTTO != 0) { + throw new ViewException("[ViewException] 구입금액은 1000원단위로 입력해주세요"); + } + } + + public static void validateNumberOfLottos(int numberOfLottos) throws ViewException { + if (numberOfLottos < 0) { + throw new ViewException("[ViewException] 로또의 수는 0이상이어야 합니다"); + } + } + + public static void validateAllLottoNos(List> lottoNos) throws ViewException { + for (List lottoNo : lottoNos) { + validateLottoNos(lottoNo); + } + } + + public static void validateLottoNos(List lottoNos) throws ViewException { + if (lottoNos.size() != NUMBER_OF_LOTTO_NOS) { + throw new ViewException("[ViewException] 로또 번호는 6자리 입니다"); + } + for (int number : lottoNos) { + validateNoRange(number); + } + } + + public static void validateNoRange(int number) throws ViewException { + if (number <= 0 || number > 45) { + throw new ViewException("[ViewException] 로또 번호는 1 ~ 45 범위 내의 숫자입니다"); + } + } +} diff --git a/src/main/java/lottoview/InputView.java b/src/main/java/lottoview/InputView.java new file mode 100644 index 0000000..7db0e62 --- /dev/null +++ b/src/main/java/lottoview/InputView.java @@ -0,0 +1,64 @@ +package lottoview; + +import java.util.ArrayList; +import java.util.List; +import java.util.Scanner; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class InputView { + public static int askPayment(Scanner scanner) throws ViewException { + System.out.println("구입금액을 입력해 주세요."); + int payment = scanner.nextInt(); + InputValidation.validatePayment(payment); + + scanner.nextLine(); + System.out.println(); + return payment; + } + + public static int askNumberOfManualLottos(Scanner scanner) throws ViewException { + System.out.println("수동으로 구매할 로또 수를 입력해 주세요."); + int numberOfManualLottos = scanner.nextInt(); + InputValidation.validateNumberOfLottos(numberOfManualLottos); + + scanner.nextLine(); + System.out.println(); + return numberOfManualLottos; + } + + public static List> askManualLottoNos(Scanner scanner, int manualCount) throws ViewException { + System.out.println("수동으로 구매할 번호를 입력해 주세요."); + List> manualLottoNos = new ArrayList<>(); + for (int i = 0; i < manualCount; i++) { + String numberText = scanner.nextLine(); + manualLottoNos.add(parseNos(numberText)); + } + InputValidation.validateAllLottoNos(manualLottoNos); + + System.out.println(); + return manualLottoNos; + } + + public static List askWinningNos(Scanner scanner) throws ViewException { + System.out.println("지난 주 당첨 번호를 입력해 주세요."); + String numberText = scanner.nextLine(); + + List winningNos = parseNos(numberText); + InputValidation.validateLottoNos(winningNos); + return winningNos; + } + + public static int askBonusNo(Scanner scanner) throws ViewException { + System.out.println("보너스 볼을 입력해 주세요."); + int bonusNo = scanner.nextInt(); + InputValidation.validateNoRange(bonusNo); + scanner.nextLine(); + return bonusNo; + } + + private static List parseNos(String numberText) { + return Stream.of(numberText.split(",")) + .map(number -> Integer.parseInt(number.trim())).collect(Collectors.toList()); + } +} diff --git a/src/main/java/lottoview/OutputView.java b/src/main/java/lottoview/OutputView.java new file mode 100644 index 0000000..5bde91c --- /dev/null +++ b/src/main/java/lottoview/OutputView.java @@ -0,0 +1,49 @@ +package lottoview; + +import lottodomain.Lotto; +import lottodomain.LottoAnalyzer; +import lottodomain.LottoNo; +import lottodomain.Rank; + +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class OutputView { + public static void showAllLottos(List allLotto, int numberOfManualLottos) { + int numberOfAutoLottos = allLotto.size() - numberOfManualLottos; + System.out.printf("수동으로 %d장, 자동으로 %d장을 구매했습니다.\n", numberOfManualLottos, numberOfAutoLottos); + allLotto.stream().forEach(lotto -> showLotto(lotto)); + } + + public static void showLotto(Lotto lotto) { + List lottoNos = lotto.getLottoNos(); + System.out.println(lottoNos.stream().map(LottoNo::getValue).map(number -> number.toString()) + .collect(Collectors.joining(", ", "[", "]"))); + } + + public static void showAnalysis(LottoAnalyzer lottoAnalyzer) { + showWRanks(lottoAnalyzer); + showEarningRate(lottoAnalyzer.calculateEarningRate()); + } + + public static void showRankCount(Rank rank, int count) { + System.out.printf("%d개 일치 (%d원)- %d개\n", rank.getCountOfMatch(), rank.getWinningMoney(), count); + } + + public static void showEarningRate(double earningRate) { + System.out.printf("총 수익률은 %.1f%%입니다.\n", earningRate); + } + + private static void showWRanks(LottoAnalyzer lottoAnalyzer) { + System.out.println("당첨 통계"); + System.out.println("---------"); + List prize = Stream.of(Rank.values()).collect(Collectors.toList()); + prize.remove(Rank.MISS); + for (int i = prize.size() - 1; i >= 0; i--) { + int count = lottoAnalyzer.countRank(prize.get(i)); + showRankCount(prize.get(i), count); + } + } +} diff --git a/src/main/java/lottoview/ViewException.java b/src/main/java/lottoview/ViewException.java new file mode 100644 index 0000000..f46bacb --- /dev/null +++ b/src/main/java/lottoview/ViewException.java @@ -0,0 +1,11 @@ +package lottoview; + +public class ViewException extends Exception { + ViewException() { + super("[ViewException]"); + } + + ViewException(String message) { + super(message); + } +} diff --git a/src/test/java/lottodomain/LottoAnalyzerTest.java b/src/test/java/lottodomain/LottoAnalyzerTest.java new file mode 100644 index 0000000..e1b8186 --- /dev/null +++ b/src/test/java/lottodomain/LottoAnalyzerTest.java @@ -0,0 +1,63 @@ +package lottodomain; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static org.junit.Assert.*; + +public class LottoAnalyzerTest { + private static final double DELTA = 1e-15; + + private List lottos; + private LottoAnalyzer lottoAnalyzer; + private WinningNos winningNos; + + @Before + public void setUp() throws Exception { + lottos = new ArrayList<>(); + lottos.add(new Lotto(Arrays.asList(1, 2, 3, 4, 5, 6))); // FIRST + lottos.add(new Lotto(Arrays.asList(1, 2, 3, 4, 5, 7))); // SECOND + lottos.add(new Lotto(Arrays.asList(1, 2, 3, 4, 5, 8))); // THIRD + lottos.add(new Lotto(Arrays.asList(1, 2, 3, 4, 7, 8))); // FOURTH + lottos.add(new Lotto(Arrays.asList(1, 2, 3, 7, 8, 9))); // FIFTH + lottos.add(new Lotto(Arrays.asList(1, 2, 7, 8, 9, 10))); // MISS + winningNos = new WinningNos(Arrays.asList(1, 2, 3, 4, 5, 6), 7); + lottoAnalyzer = new LottoAnalyzer(lottos, winningNos); + } + + @Test + public void calculateRankOfLotto() { + List ranks = Arrays.asList(Rank.values()); + for (int i = 0; i < lottos.size(); i++) { + assertEquals(ranks.get(i), lottoAnalyzer.calculateRankOfLotto(lottos.get(i), winningNos)); + } + } + + @Test + public void calculateEarnedMoney() { + assertEquals(2031555000, lottoAnalyzer.calculateEarnedMoney()); + } + + @Test + public void calculateEarningRate() { + assertEquals(33859250.0, lottoAnalyzer.calculateEarningRate(), DELTA); + } + + @Test + public void countRank() { + List ranks = Arrays.asList(Rank.values()); + for (int i = 0; i < ranks.size(); i++) { + assertEquals(1, lottoAnalyzer.countRank(ranks.get(i))); + } + } + + @After + public void tearDown() throws Exception { + lottos = null; + } +} \ No newline at end of file diff --git a/src/test/java/lottodomain/LottoGameTest.java b/src/test/java/lottodomain/LottoGameTest.java new file mode 100644 index 0000000..1c8977a --- /dev/null +++ b/src/test/java/lottodomain/LottoGameTest.java @@ -0,0 +1,47 @@ +package lottodomain; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +import static org.junit.Assert.*; + +public class LottoGameTest { + private LottoGame lottoGame; + List> manualLottoNumbers; + + private void assertArrayEquals(List expectedLottos, List subList) { + for (int i = 0; i < expectedLottos.size(); i++) { + assertEquals(expectedLottos.get(i), subList.get(i)); + } + } + + @Before + public void setUp() throws Exception { + manualLottoNumbers = new ArrayList<>(); + manualLottoNumbers.add(Arrays.asList(1, 2, 3, 4, 5, 6)); + manualLottoNumbers.add(Arrays.asList(1, 4, 11, 15, 19, 23)); + manualLottoNumbers.add(Arrays.asList(4, 10, 17, 25, 34, 42)); + } + + @Test + public void setManualLottos() { + lottoGame = new LottoGame(10000, manualLottoNumbers); + assertEquals(10, lottoGame.getAllLotto().size()); + + List expectedLottos = manualLottoNumbers.stream().map(numbers -> LottoGenerator.generateLottoWithNos(numbers)) + .collect(Collectors.toList()); + assertArrayEquals(expectedLottos, lottoGame.getAllLotto().subList(0, 3)); + } + + @After + public void tearDown() throws Exception { + lottoGame = null; + manualLottoNumbers = null; + } +} \ No newline at end of file diff --git a/src/test/java/lottodomain/LottoGeneratorTest.java b/src/test/java/lottodomain/LottoGeneratorTest.java new file mode 100644 index 0000000..d8d55d1 --- /dev/null +++ b/src/test/java/lottodomain/LottoGeneratorTest.java @@ -0,0 +1,32 @@ +package lottodomain; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.Assert.*; +import static org.hamcrest.CoreMatchers.instanceOf; + +public class LottoGeneratorTest { + private List numbers; + + @Before + public void setUp() throws Exception { + numbers = Arrays.asList(1, 2, 3, 4, 5, 6); + } + + @Test + public void generateLottoWithNos() { + assertThat(LottoGenerator.generateLottoWithNos(numbers), instanceOf(Lotto.class)); + Lotto lotto = LottoGenerator.generateLottoWithNos(numbers); + assertEquals(6, lotto.getLottoNos().size()); + } + + @After + public void tearDown() throws Exception { + numbers = null; + } +} \ No newline at end of file diff --git a/src/test/java/lottodomain/LottoTest.java b/src/test/java/lottodomain/LottoTest.java new file mode 100644 index 0000000..8e90bbf --- /dev/null +++ b/src/test/java/lottodomain/LottoTest.java @@ -0,0 +1,54 @@ +package lottodomain; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.junit.Assert.*; + +public class LottoTest { + private Lotto lotto; + private List lottoNos = Arrays.asList(1, 2, 3, 4, 5, 6); + + @Before + public void setUp() throws Exception { + lotto = new Lotto(lottoNos); + } + + @Test + public void getLottoNos() { + lotto.getLottoNos().stream().forEach(lottoNo -> assertThat(lottoNo, instanceOf(LottoNo.class))); + assertEquals(6, lotto.getLottoNos().size()); + } + + @Test + public void contains() { + assertTrue(lotto.contains(new LottoNo(1))); + assertTrue(lotto.contains(new LottoNo(2))); + assertTrue(lotto.contains(new LottoNo(3))); + assertTrue(lotto.contains(new LottoNo(4))); + assertTrue(lotto.contains(new LottoNo(5))); + assertTrue(lotto.contains(new LottoNo(6))); + assertFalse(lotto.contains(new LottoNo(0))); + assertFalse(lotto.contains(new LottoNo(7))); + } + + @Test + public void testEquals() { + Lotto sameLotto = new Lotto(lottoNos); + Lotto otherLotto = new Lotto(Arrays.asList(1, 2, 3, 4, 5, 7)); + + assertTrue(lotto.equals(sameLotto)); + assertFalse(lotto.equals(otherLotto)); + } + + @After + public void tearDown() throws Exception { + lotto = null; + lottoNos = null; + } +} \ No newline at end of file diff --git a/src/test/java/lottodomain/RankTest.java b/src/test/java/lottodomain/RankTest.java new file mode 100644 index 0000000..1185432 --- /dev/null +++ b/src/test/java/lottodomain/RankTest.java @@ -0,0 +1,17 @@ +package lottodomain; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class RankTest { + @Test + public void valueOf() { + assertEquals(Rank.FIRST, Rank.valueOf(6, false)); + assertEquals(Rank.SECOND, Rank.valueOf(5, true)); + assertEquals(Rank.THIRD, Rank.valueOf(5, false)); + assertEquals(Rank.FOURTH, Rank.valueOf(4, false)); + assertEquals(Rank.FIFTH, Rank.valueOf(3, false)); + assertEquals(Rank.MISS, Rank.valueOf(1, false)); + } +} \ No newline at end of file diff --git a/src/test/java/lottodomain/WinningNosTest.java b/src/test/java/lottodomain/WinningNosTest.java new file mode 100644 index 0000000..7a8a4eb --- /dev/null +++ b/src/test/java/lottodomain/WinningNosTest.java @@ -0,0 +1,50 @@ +package lottodomain; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static org.junit.Assert.*; + +public class WinningNosTest { + private WinningNos winningNos; + + @Before + public void setUp() throws Exception { + winningNos = new WinningNos(Arrays.asList(1, 2, 3, 4, 5, 6), 7); + } + + @Test + public void countMatchOf() { + List lottos = new ArrayList<>(); + lottos.add(new Lotto(Arrays.asList(8, 9, 10, 11, 12, 13))); + lottos.add(new Lotto(Arrays.asList(1, 8, 9, 10, 11, 12))); + lottos.add(new Lotto(Arrays.asList(1, 2, 9, 10, 11, 12))); + lottos.add(new Lotto(Arrays.asList(1, 2, 3, 10, 11, 12))); + lottos.add(new Lotto(Arrays.asList(1, 2, 3, 4, 11, 12))); + lottos.add(new Lotto(Arrays.asList(1, 2, 3, 4, 5, 12))); + lottos.add(new Lotto(Arrays.asList(1, 2, 3, 4, 5, 6))); + + for (int i = 0; i < lottos.size(); i++) { + assertEquals(i, winningNos.countMatchOf(lottos.get(i))); + } + } + + @Test + public void isBonus() { + Lotto trueLotto = new Lotto(Arrays.asList(1, 2, 3, 4, 5, 6, 7)); + Lotto falseLotto = new Lotto(Arrays.asList(1, 2, 3, 4, 5, 6, 8)); + + assertTrue(winningNos.isBonus(trueLotto)); + assertFalse(winningNos.isBonus(falseLotto)); + } + + @After + public void tearDown() throws Exception { + winningNos = null; + } +} \ No newline at end of file