diff --git a/build.gradle b/build.gradle index 14c315c..0de849e 100644 --- a/build.gradle +++ b/build.gradle @@ -13,4 +13,5 @@ repositories { dependencies { testCompile group: 'junit', name: 'junit', version: '4.12' + testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3' } diff --git a/src/main/java/Bridge.java b/src/main/java/Bridge.java deleted file mode 100644 index 1c7e4a2..0000000 --- a/src/main/java/Bridge.java +++ /dev/null @@ -1,26 +0,0 @@ -import java.util.List; - -public class -Bridge { - private Integer height; - private List points; - - public Bridge(Integer height, List points) { - this.height = height; - this.points = points; - } - - public Point nextPoint(int currentColumn) { - Point point = points.get(currentColumn); - if (point.getLinkedType() == LinkedType.RIGHT) { - Point nextPoint = points.get(currentColumn + 1); - return nextPoint; - } - if (point.getLinkedType() == LinkedType.LEFT) { - Point nextPoint = points.get(currentColumn-1); - return nextPoint; - } - - return point; - } -} diff --git a/src/main/java/LadderGame.java b/src/main/java/LadderGame.java index c8265a2..253e8b9 100644 --- a/src/main/java/LadderGame.java +++ b/src/main/java/LadderGame.java @@ -1,4 +1,28 @@ +import domain.ladder.Ladder; +import domain.ladderCalculator.LadderIO; +import dto.GameStartOption; +import view.InputView; +import view.OutputLadder; + public class LadderGame { + public static void main(String args[]) { + + InputView inputView = InputView.of(System.in); + GameStartOption gameStartOption = inputView.initGameStartOption(); + Ladder ladder = Ladder.of(gameStartOption); + LadderIO ladderIO = LadderIO.of(gameStartOption); + OutputLadder ladderPrint = OutputLadder.of(ladderIO, ladder); + + ladderPrint.drawUserNames(); + ladderPrint.drawOutput(); + ladderPrint.drawResults(); + + while (true) { + String ask = inputView.showResultUser(); + ladderPrint.showLadderResult(ask); + } + + } } diff --git a/src/main/java/LinkedType.java b/src/main/java/LinkedType.java deleted file mode 100644 index 60af498..0000000 --- a/src/main/java/LinkedType.java +++ /dev/null @@ -1,3 +0,0 @@ -public enum LinkedType { - RIGHT,LEFT,NONE -} diff --git a/src/main/java/Point.java b/src/main/java/Point.java deleted file mode 100644 index d5cc9b7..0000000 --- a/src/main/java/Point.java +++ /dev/null @@ -1,30 +0,0 @@ -public class Point { - private Integer column; - private LinkedType linkedType; - - private Point(Integer column,LinkedType linkedType) { - this.column = column; - this.linkedType = linkedType; - } - - public LinkedType getLinkedType() { - return linkedType; - } - - public int getColumn() { - return column; - } - - public static Point createRightLinkedPoint(Integer column){ - return new Point(column,LinkedType.RIGHT); - } - - public static Point createLeftLinkedPoint(Integer column){ - return new Point(column,LinkedType.LEFT); - } - - public static Point createNotLinkedPoint(Integer column){ - return new Point(column,LinkedType.NONE); - } - -} diff --git a/src/main/java/domain/converter/OutputConverter.java b/src/main/java/domain/converter/OutputConverter.java new file mode 100644 index 0000000..1c4c256 --- /dev/null +++ b/src/main/java/domain/converter/OutputConverter.java @@ -0,0 +1,26 @@ +package domain.converter; + +import domain.ladder.Ladder; + +import java.util.ArrayList; +import java.util.List; + +public class OutputConverter { + private List rows = new ArrayList<>(); + + private OutputConverter(Ladder ladder) { + for (int location = 0; location < ladder.getHeight(); location++) { + rows.add(Row.of(location, ladder)); + } + } + + public static OutputConverter of(Ladder ladder) { + return new OutputConverter(ladder); + } + + public List getRows() { + return new ArrayList<>(rows); + } + + +} diff --git a/src/main/java/domain/converter/Point.java b/src/main/java/domain/converter/Point.java new file mode 100644 index 0000000..5f91022 --- /dev/null +++ b/src/main/java/domain/converter/Point.java @@ -0,0 +1,47 @@ +package domain.converter; + +import domain.ladder.Bridge; + +import java.util.Optional; + +public class Point implements Comparable { + private Integer pillarNum; + private Bridge bridge; + + private Point(Integer pillarNum, Bridge bridge) { + this.pillarNum = pillarNum; + this.bridge = bridge; + } + + private Point(Integer pillarNum) { + this.pillarNum = pillarNum; + } + + public static Point of(Integer pillarNum, Optional bridge) { + if (bridge.isPresent()) + return new Point(pillarNum, bridge.get()); + return new Point(pillarNum); + } + + public boolean isBlankPoint() { + return bridge == null; + } + + @Override + public String toString() { + return "pillarNum:" + pillarNum + "/" + "bridge:" + bridge.getLocation(); + } + + public Integer getPillarNum() { + return pillarNum; + } + + public Bridge getBridge() { + return bridge; + } + + @Override + public int compareTo(Point o) { + return pillarNum.compareTo(o.pillarNum); + } +} diff --git a/src/main/java/domain/converter/Row.java b/src/main/java/domain/converter/Row.java new file mode 100644 index 0000000..6ec9cd1 --- /dev/null +++ b/src/main/java/domain/converter/Row.java @@ -0,0 +1,39 @@ +package domain.converter; + +import domain.ladder.Ladder; + +import java.util.List; +import java.util.stream.Collectors; + +public class Row implements Comparable { + private Integer location; + private List points; + + private Row(Integer location, Ladder ladder) { + this.location = location; + this.points = findLocationBridge(ladder); + } + + public static Row of(Integer location, Ladder ladder) { + return new Row(location, ladder); + } + + private List findLocationBridge(Ladder ladder) { + return ladder.getPillars().stream() + .map(pillar -> Point.of(pillar.getPillarNum(), pillar.getLevelBridges(location))) + .collect(Collectors.toList()); + } + + public Integer getLocation() { + return location; + } + + public List getPoints() { + return points; + } + + @Override + public int compareTo(Row o) { + return location.compareTo(o.location); + } +} \ No newline at end of file diff --git a/src/main/java/domain/factory/PillarFactory.java b/src/main/java/domain/factory/PillarFactory.java new file mode 100644 index 0000000..99504b4 --- /dev/null +++ b/src/main/java/domain/factory/PillarFactory.java @@ -0,0 +1,35 @@ +package domain.factory; + +import domain.ladder.Bridge; +import domain.ladder.Pillar; +import domain.maker.PillarMaker; +import dto.GameStartOption; + +import java.util.List; + +public class PillarFactory { + + public static final int MINIMUM_PILLAR_NUM = 0; + + public Pillar createFirstPillar(GameStartOption gameStartOption) { + + List bridges = PillarMaker.of().createBridgesInThisPillar(gameStartOption); + Integer pillarNum = MINIMUM_PILLAR_NUM; + + return Pillar.of(bridges, pillarNum); + } + + public Pillar createNotFirstPillar(GameStartOption gameStartOption, Pillar previousPillar) { + + List bridges = PillarMaker.of().createBridgesInThisPillar(gameStartOption, previousPillar); + Integer pillarNum = nowPillarNum(previousPillar); + + return Pillar.of(bridges, pillarNum); + + } + + private Integer nowPillarNum(Pillar previousPillar) { + return previousPillar.getPillarNum() + 1; + } + +} diff --git a/src/main/java/domain/ladder/Bridge.java b/src/main/java/domain/ladder/Bridge.java new file mode 100644 index 0000000..46b36ed --- /dev/null +++ b/src/main/java/domain/ladder/Bridge.java @@ -0,0 +1,33 @@ +package domain.ladder; + +public class Bridge { + private Integer location; + private LinkedType linkPillarDirection; + + + private Bridge(Integer location, LinkedType linkPillarDirection) { + this.location = location; + this.linkPillarDirection = linkPillarDirection; + } + + public static Bridge of(Integer location , LinkedType linkPillarDirection){ + return new Bridge(location, linkPillarDirection); + } + + public Integer getLocation() { + return location; + } + + public LinkedType getLinkPillarDirection() { + return linkPillarDirection; + } + + public static Bridge createOneRightBridge(Integer location) { + return (new Bridge(location, LinkedType.RIGHT)); + } + + public static Bridge createOneLeftBridge(Integer location) { + return (new Bridge(location, LinkedType.LEFT)); + } + +} diff --git a/src/main/java/domain/ladder/Ladder.java b/src/main/java/domain/ladder/Ladder.java new file mode 100644 index 0000000..25753c8 --- /dev/null +++ b/src/main/java/domain/ladder/Ladder.java @@ -0,0 +1,53 @@ +package domain.ladder; + +import domain.maker.LadderMaker; +import dto.GameStartOption; + +import java.util.List; +import java.util.Optional; + +public class Ladder { + + private List pillars; + private Integer width; + private Integer height; + + private Ladder(GameStartOption gameStartOption) { + this.width = gameStartOption.getLadderWidth(); + this.height = gameStartOption.getLadderHeight(); + this.pillars = LadderMaker.of().createLadder(gameStartOption); + } + + public static Ladder of(GameStartOption gameStartOption) { + return new Ladder(gameStartOption); + } + + public Pillar getPillarByNum(Integer pillarNum) { + return pillars.stream() + .filter(p -> p.getPillarNum() == pillarNum) + .findFirst() + .orElseThrow(IllegalArgumentException::new); // optional orElse에 null 던지지 말기 throw Exception + } + + public List getPillars() { + return pillars; + } + + public Integer getWidth() { + return width; + } + + public Integer getHeight() { + return height; + } + + public Pillar getNextPillar(Pillar nowPillar, Integer nowLocation) { + Optional linkBridge = nowPillar.getLevelBridges(nowLocation); + if (!linkBridge.isPresent()) + return nowPillar; + return linkBridge.get().getLinkPillarDirection() == LinkedType.RIGHT ? + getPillarByNum(nowPillar.getPillarNum() + 1) : + getPillarByNum(nowPillar.getPillarNum() - 1); + } + +} diff --git a/src/main/java/domain/ladder/LinkedType.java b/src/main/java/domain/ladder/LinkedType.java new file mode 100644 index 0000000..3fc8afc --- /dev/null +++ b/src/main/java/domain/ladder/LinkedType.java @@ -0,0 +1,5 @@ +package domain.ladder; + +public enum LinkedType { + RIGHT, LEFT +} diff --git a/src/main/java/domain/ladder/Pillar.java b/src/main/java/domain/ladder/Pillar.java new file mode 100644 index 0000000..d30a499 --- /dev/null +++ b/src/main/java/domain/ladder/Pillar.java @@ -0,0 +1,49 @@ +package domain.ladder; + +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +public class Pillar { + + private List bridges; + private Integer pillarNum; + + private Pillar(List bridges, Integer pillarNum) { + this.bridges = bridges; + this.pillarNum = pillarNum; + } + + public static Pillar of(List bridges, Integer pillarNum) { + return new Pillar(bridges, pillarNum); + } + + public Integer getPillarNum() { + return pillarNum; + } + + public List getBridges() { + return bridges; + } + + + public Optional getLevelBridges(Integer level) { + return bridges.stream() + .filter(bridge -> bridge.getLocation().equals(level)) + .findFirst(); + } + + public List getBridgesLocations() { + return bridges.stream() + .map(b -> b.getLocation()) + .collect(Collectors.toList()); + } + + public List getBridgesDirectionLocation(LinkedType linkedType) { + return bridges.stream() + .filter(b -> b.getLinkPillarDirection() == linkedType) + .map(bridge -> bridge.getLocation()) + .collect(Collectors.toList()); + } + +} \ No newline at end of file diff --git a/src/main/java/domain/ladderCalculator/LadderIO.java b/src/main/java/domain/ladderCalculator/LadderIO.java new file mode 100644 index 0000000..85f2265 --- /dev/null +++ b/src/main/java/domain/ladderCalculator/LadderIO.java @@ -0,0 +1,52 @@ +package domain.ladderCalculator; + +import domain.ladder.Ladder; +import domain.ladder.Pillar; +import dto.GameStartOption; + +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +import static util.RandomIntegerMaker.separateByDelimiter; + +public class LadderIO { + + private List users; + private List results; + + private LadderIO(GameStartOption gameStartOption) { + this.users = separateByDelimiter(gameStartOption.getParticipants()); + this.results = separateByDelimiter(gameStartOption.getResults()); + } + + public static LadderIO of(GameStartOption gameStartOption) { + return new LadderIO(gameStartOption); + } + + public List getUsers() { + return users; + } + + public List getResults() { + return results; + } + + public String findResult(Ladder ladder, String userName) { + int row = 0; + Pillar pillar = ladder.getPillarByNum(users.indexOf(userName)); + while (row < ladder.getHeight()) { + pillar = ladder.getNextPillar(pillar, row); + row++; + } + return results.get(pillar.getPillarNum()); + } + + public int getUserCharMaxNum() { + List lengths = users.stream() + .map(u -> u.length()) + .collect(Collectors.toList()); + return Collections.max(lengths); + } + +} diff --git a/src/main/java/domain/maker/LadderMaker.java b/src/main/java/domain/maker/LadderMaker.java new file mode 100644 index 0000000..7ef3fa6 --- /dev/null +++ b/src/main/java/domain/maker/LadderMaker.java @@ -0,0 +1,32 @@ +package domain.maker; + +import domain.factory.PillarFactory; +import domain.ladder.Ladder; +import domain.ladder.Pillar; +import dto.GameStartOption; + +import java.util.ArrayList; +import java.util.List; + +public class LadderMaker { + + private List pillars = new ArrayList<>(); + private PillarFactory pillarFactory = new PillarFactory(); + + private LadderMaker(){}; + + public static LadderMaker of(){ + return new LadderMaker(); + } + + public List createLadder(GameStartOption gameStartOption) { + Pillar previous = pillarFactory.createFirstPillar(gameStartOption); + pillars.add(previous); + for (int i = 1; i < gameStartOption.getLadderWidth(); i++) { + Pillar now = pillarFactory.createNotFirstPillar(gameStartOption, previous); + pillars.add(now); + previous = now; + } + return new ArrayList<>(pillars); + } +} diff --git a/src/main/java/domain/maker/PillarMaker.java b/src/main/java/domain/maker/PillarMaker.java new file mode 100644 index 0000000..9b7927f --- /dev/null +++ b/src/main/java/domain/maker/PillarMaker.java @@ -0,0 +1,57 @@ +package domain.maker; + +import domain.ladder.Bridge; +import domain.ladder.LinkedType; +import domain.ladder.Pillar; +import dto.GameStartOption; + +import java.util.ArrayList; +import java.util.List; + +import static util.RandomIntegerMaker.createRandomIntegers; +import static util.RandomIntegerMaker.createRandomIntegersWithRestriction; + +public class PillarMaker { + + private PillarMaker(){} + + public static PillarMaker of(){ + return new PillarMaker(); + } + + private static final Integer LAST_PILLAR_CHECKING_NUM = 2; + private List bridges = new ArrayList<>(); + + public List createBridgesInThisPillar(GameStartOption gameStartOption, Pillar previousPillar) { + createLeftOnlyBridges(previousPillar); + if (!isLastPillar(gameStartOption, previousPillar)) + createRightOnlyBridges(gameStartOption.getLadderHeight(), previousPillar); + return new ArrayList<>(bridges); + } + + public List createBridgesInThisPillar(GameStartOption gameStartOption) { + createRightOnlyBridges(gameStartOption.getLadderHeight()); + return new ArrayList<>(bridges); + } + + private void createRightOnlyBridges(Integer ladderHeight) { + createRandomIntegers(ladderHeight).stream() + .forEach(b -> bridges.add(Bridge.createOneRightBridge(b))); + } + + private void createRightOnlyBridges(Integer ladderHeight, Pillar previous) { + List previousLocations = previous.getBridgesDirectionLocation(LinkedType.RIGHT); + createRandomIntegersWithRestriction(ladderHeight, previousLocations).stream() + .forEach(b -> bridges.add(Bridge.createOneRightBridge(b))); + } + + private void createLeftOnlyBridges(Pillar previous) { + previous.getBridgesDirectionLocation(LinkedType.RIGHT).stream() + .forEach(b -> bridges.add(Bridge.createOneLeftBridge(b))); + } + + private boolean isLastPillar(GameStartOption gameStartOption, Pillar previousPillar) { + return gameStartOption.getLadderWidth() - previousPillar.getPillarNum() == LAST_PILLAR_CHECKING_NUM; + } + +} diff --git a/src/main/java/domain/user/ParticipantUsers.java b/src/main/java/domain/user/ParticipantUsers.java new file mode 100644 index 0000000..d84f31b --- /dev/null +++ b/src/main/java/domain/user/ParticipantUsers.java @@ -0,0 +1,36 @@ +package domain.user; + +import dto.GameStartOption; + +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +import static util.RandomIntegerMaker.separateUserName; + +public class ParticipantUsers { + private List users; + + public ParticipantUsers(GameStartOption gameStartOption) { + this.users = createUser(gameStartOption.getParticipants()); + } + + public List getUsers() { + return users; + } + + private List createUser(String users) { + return separateUserName(users).stream() + .map(u -> new User(u)) + .collect(Collectors.toList()); + } + + public int getUserCharMaxNum() { + List lengths = users.stream() + .map(u -> u.getName().length()) + .collect(Collectors.toList()); + return Collections.max(lengths); + } + + +} diff --git a/src/main/java/domain/user/User.java b/src/main/java/domain/user/User.java new file mode 100644 index 0000000..efe026a --- /dev/null +++ b/src/main/java/domain/user/User.java @@ -0,0 +1,18 @@ +package domain.user; + +public class User { + + //user's PillarNum 갖고있게 하기, + //결과 반환하는것 만들기 + + private String name; + + public User(String name) { + this.name = name; + } + + public String getName() { + return name; + } + +} diff --git a/src/main/java/dto/GameStartOption.java b/src/main/java/dto/GameStartOption.java new file mode 100644 index 0000000..4ddff1a --- /dev/null +++ b/src/main/java/dto/GameStartOption.java @@ -0,0 +1,54 @@ +package dto; + +public class GameStartOption { + + public static final String DELIMITER = ","; + public static final int MINIMUM_LADDER_HEIGHT = 1; + public static final int MINIMUM_PARTICIPANTS_COUNT = 2; + + + private int ladderHeight; + private String participants; + private String results; + + public GameStartOption(String participants, int ladderHeight, String results) { + this.ladderHeight = ladderHeight; + this.participants = participants; + this.results = results; + validate(); + } + + public static GameStartOption of(String participants, int ladderHeight, String results){ + return new GameStartOption(participants, ladderHeight, results); + } + + private int getLadderWidth(String participants) { + String[] parts = participants.split(DELIMITER); + return parts.length; + } + + public String getParticipants() { + return participants; + } + + public int getLadderWidth() { + return getLadderWidth(participants); + } + + public int getLadderHeight() { + return ladderHeight; + } + + public String getResults() { + return results; + } + + private void validate(){ + if(ladderHeight < MINIMUM_LADDER_HEIGHT) + throw new IllegalArgumentException("올바른 사다리 높이를 입력해주세요."); + if(getLadderWidth() < MINIMUM_PARTICIPANTS_COUNT ) + throw new IllegalArgumentException(("참가자 수를 2명이상 입력해주세요.")); + if(participants.split(DELIMITER).length != results.split(DELIMITER).length) + throw new IllegalArgumentException(("결과와 참가자 수를 동일하게 입력해주세요.")); + } +} diff --git a/src/main/java/util/RandomIntegerMaker.java b/src/main/java/util/RandomIntegerMaker.java new file mode 100644 index 0000000..fae9898 --- /dev/null +++ b/src/main/java/util/RandomIntegerMaker.java @@ -0,0 +1,41 @@ +package util; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import static dto.GameStartOption.DELIMITER; + +public class RandomIntegerMaker { + + public static final int MIN_HEIGHT_INDEX = 0; + + public static List createRandomIntegers(Integer heights) { + List randoms = IntStream.range(MIN_HEIGHT_INDEX, heights) + .mapToObj(Integer::new) + .collect(Collectors.toList()); + Collections.shuffle(randoms); + + return randoms.stream() + .limit(randInt(heights)) + .collect(Collectors.toList()); + } + + public static List createRandomIntegersWithRestriction(Integer ladderHeight, List restrictions) { + List randoms = createRandomIntegers(ladderHeight); + return randoms.stream() + .filter(i -> !restrictions.contains(i)) + .collect(Collectors.toList()); + } + + public static List separateByDelimiter(String inputString) { + String[] splitString = inputString.split(DELIMITER); + return Arrays.asList(splitString); + } + + public static Integer randInt(int bound) { + return (int) (Math.random() * bound + 1); + } +} diff --git a/src/main/java/view/InputView.java b/src/main/java/view/InputView.java new file mode 100644 index 0000000..1356997 --- /dev/null +++ b/src/main/java/view/InputView.java @@ -0,0 +1,50 @@ +package view; + + +import dto.GameStartOption; + +import java.io.InputStream; +import java.util.Scanner; + +public class InputView { + public static Scanner sc; + + + private InputView(InputStream inputStream) { + sc = new Scanner(inputStream); + } + + public static InputView of(InputStream inputStream){ + return new InputView(inputStream); + } + + public String participants() { + System.out.println("참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)"); + return sc.next(); + } + + + public String results(){ + System.out.println("실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)"); + return sc.next(); + + } + public int ladderHeight() { + System.out.println("최대 사다리 높이는 몇 개인가요?"); + return sc.nextInt(); + } + + public String showResultUser() { + System.out.println("결과를 보고싶은 사람은?"); + return sc.next(); + } + + public GameStartOption initGameStartOption(){ + String participants = participants(); + String results = results(); + int ladderHeight = ladderHeight(); + + return new GameStartOption(participants, ladderHeight, results); + } + +} diff --git a/src/main/java/view/OutputLadder.java b/src/main/java/view/OutputLadder.java new file mode 100644 index 0000000..a7b255e --- /dev/null +++ b/src/main/java/view/OutputLadder.java @@ -0,0 +1,99 @@ +package view; + +import domain.converter.OutputConverter; +import domain.converter.Point; +import domain.converter.Row; +import domain.ladder.Ladder; +import domain.ladder.LinkedType; +import domain.ladderCalculator.LadderIO; + +import java.util.Collections; +import java.util.List; +import java.util.stream.IntStream; + +import static view.OutputLine.*; + +public class OutputLadder { + private LadderIO ladderIO; + private Ladder ladder; + + private OutputLadder(LadderIO ladderIO, Ladder ladder) { + this.ladder = ladder; + this.ladderIO = ladderIO; + } + + public static OutputLadder of(LadderIO ladderIO, Ladder ladder) { + return new OutputLadder(ladderIO, ladder); + } + + public void drawOutput() { + List rows = OutputConverter.of(ladder).getRows(); + Collections.sort(rows); + for (Row row : rows) { + drawRow(row); + } + } + + public void drawUserNames() { + StringBuilder sb = new StringBuilder(); + for (String user : ladderIO.getUsers()) { + sb.append(user); + sb.append(calculateBlank(user)); + sb.append(BLANK); + } + System.out.println(sb); + } + + public void drawResults() { + StringBuilder sb = new StringBuilder(); + for (String result : ladderIO.getResults()) { + sb.append(result); + sb.append(calculateBlank(result)); + sb.append(BLANK); + } + System.out.println(sb); + } + + public void showLadderResult(String userName) { + String result = userName.equals("all") ? showAllResult() : ladderIO.findResult(ladder, userName); + System.out.println(result); + } + + private String showAllResult() { + StringBuilder sb = new StringBuilder(); + for (String user : ladderIO.getUsers()) { + sb.append(user + ":" + ladderIO.findResult(ladder, user)+"\n"); + } + return sb.toString(); + } + + private void drawRow(Row row) { + List points = row.getPoints(); + Collections.sort(points); + for (Point point : points) { + System.out.print(drawPoint(point)); + } + System.out.println(); + } + + private String drawPoint(Point point) { + int repeat = ladderIO.getUserCharMaxNum(); + return point.isBlankPoint() ? DOWN + widthBlank(repeat) : Link(point); + } + + private String calculateBlank(String result) { + int width = ladderIO.getUserCharMaxNum() - result.length(); + StringBuilder sb = new StringBuilder(); + IntStream.range(0, width) + .forEach(each -> sb.append(BLANK)); + return sb.toString(); + } + + private String Link(Point point) { + int repeat = ladderIO.getUserCharMaxNum(); + if (point.getBridge().getLinkPillarDirection() == LinkedType.RIGHT) + return RIGHT + widthLine(repeat); + return LEFT + widthBlank(repeat); + } + +} diff --git a/src/main/java/view/OutputLine.java b/src/main/java/view/OutputLine.java new file mode 100644 index 0000000..158c497 --- /dev/null +++ b/src/main/java/view/OutputLine.java @@ -0,0 +1,17 @@ +package view; + +public class OutputLine { + public static final String DOWN = "│"; + public static final String HORIZON = "─"; + public static final String RIGHT = "├"; + public static final String LEFT = "┤"; + public static final String BLANK = " "; + + public static String widthLine(int repeat) { + return new String(new char[repeat]).replace("\0", HORIZON); + } + + public static String widthBlank(int repeat) { + return new String(new char[repeat]).replace("\0", BLANK); + } +} diff --git a/src/main/java/view/OutputView.java b/src/main/java/view/OutputView.java new file mode 100644 index 0000000..d4342fb --- /dev/null +++ b/src/main/java/view/OutputView.java @@ -0,0 +1,120 @@ +package view; + +import domain.ladder.Ladder; +import domain.ladder.LinkedType; +import domain.ladder.Pillar; +import domain.user.ParticipantUsers; +import domain.user.User; + +import java.util.Arrays; +import java.util.stream.IntStream; + +public class OutputView { + +// 가로로 찍을 수 있게 변환해서 +// dto로 bridge와 그 높이 들고있는 dto만들어서 가로로 변환해서 +// 찍기 편한 형태로 변환하기 +// flatMap으로 쭉 적으면서 +// bridge 1개랑 level 들고있으면 (Converter class 만들기) + + + /* + 높이만큼 돌고 높이 1일 때 + */ + + public static final int PILLAR_WIDTH_SURPLUS = 1; + private static final char DOWN = '│'; + private static final char HORIZON = '─'; + private static final char RIGHT = '├'; + private static final char LEFT = '┤'; + private static final char BLANK = ' '; + + private char[][] ladderDrawing; + private int basicNum; + private int ladderHeight; + private ParticipantUsers participantUsers; + + public OutputView(ParticipantUsers participantUsers, Ladder ladder) { + this.basicNum = calculateBasicsNum(participantUsers); + this.ladderHeight = ladder.getHeight(); + this.ladderDrawing = drawAllLadder(ladder); + this.participantUsers = participantUsers; + } + + public void printLadder() { + System.out.println(makeUserNames()); + System.out.println(makeStringLadder()); + } + + private String makeStringLadder() { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < ladderHeight; i++) { + sb.append(new String(ladderDrawing[i]) + "\n"); + } + return sb.toString(); + } + + private String makeUserNames() { + StringBuilder sb = new StringBuilder(); + for (User user : participantUsers.getUsers()) { + sb.append(user.getName()); + sb.append(nameBlank(user)); + } + return sb.toString(); + } + + + private String nameBlank(User user) { + int width = basicNum - user.getName().length() + PILLAR_WIDTH_SURPLUS; + StringBuilder sb = new StringBuilder(); + IntStream.range(0, width) + .forEach(each -> sb.append(BLANK)); + return sb.toString(); + } + + private char[][] drawAllLadder(Ladder ladder) { + char[][] charLadder = drawLadderInit(ladder); + for (int i = 0; i < ladder.getWidth(); i++) { + drawPillar(charLadder, ladder.getPillarByNum(i)); + } + return charLadder; + } + + private char[][] drawLadderInit(Ladder ladder) { + char[][] charLadder = new char[ladderHeight][calculateDrawingWidth(ladder)]; + for (int i = 0; i < ladderHeight; i++) { + Arrays.fill(charLadder[i], BLANK); + } + return charLadder; + } + + private void drawPillar(char[][] charLadder, Pillar pillar) { + for (int i = 0; i < ladderHeight; i++) { + int mainPillarIdx = pillar.getPillarNum() * (basicNum + PILLAR_WIDTH_SURPLUS); + charLadder[i][mainPillarIdx] = DOWN; + } + for (Integer location : pillar.getBridgesDirectionLocation(LinkedType.RIGHT)) { + drawPillarWithRIGHTLink(charLadder[location], pillar.getPillarNum()); + } + for (Integer location : pillar.getBridgesDirectionLocation(LinkedType.LEFT)) { + charLadder[location][pillar.getPillarNum() * (basicNum + PILLAR_WIDTH_SURPLUS)] = LEFT; + } + } + + private void drawPillarWithRIGHTLink(char[] ladderRow, Integer pillarNum) { + int mainPillarIdx = pillarNum * (basicNum + PILLAR_WIDTH_SURPLUS); + ladderRow[mainPillarIdx] = RIGHT; + for (int i = mainPillarIdx + PILLAR_WIDTH_SURPLUS; i <= mainPillarIdx + basicNum; i++) { + ladderRow[i] = HORIZON; + } + } + + private int calculateDrawingWidth(Ladder ladder) { + return ladder.getWidth() * basicNum; + } + + private int calculateBasicsNum(ParticipantUsers participantUsers) { + return participantUsers.getUserCharMaxNum(); + } + +} diff --git a/src/test/java/BridgeTest.java b/src/test/java/BridgeTest.java deleted file mode 100644 index a5dcb6a..0000000 --- a/src/test/java/BridgeTest.java +++ /dev/null @@ -1,30 +0,0 @@ -import org.junit.Test; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import static org.junit.Assert.*; - -public class BridgeTest { - - @Test - public void 첫번째_브릿지_생성하기() { - //given - Integer height = 1; - Point leftPoint = Point.createRightLinkedPoint(1); - Point rightPoint = Point.createLeftLinkedPoint(2); - Bridge firstBridge = new Bridge(height, Arrays.asList(leftPoint,rightPoint)); - //when - //then - assertEquals(firstBridge.nextPoint(currentColumn),rightPoint); - assertEquals(firstBridge.nextPoint(1),leftPoint); - } - - @Test - public void 첫번쨰_브릿지_연결안된거() { - //given - //when - //then - } -} \ No newline at end of file diff --git a/src/test/java/LadderGameTest.java b/src/test/java/LadderGameTest.java deleted file mode 100644 index 5d88e75..0000000 --- a/src/test/java/LadderGameTest.java +++ /dev/null @@ -1,17 +0,0 @@ -//import org.junit.Test; -// -//import static org.junit.Assert.*; -// -//public class LadderGameTest { -// -// @Test -// public void 사다리_만들기() { -// //given -// int playerNumber = 5; -// LadderGame ladderGame = new LadderGame(); -// //when -// = ladderGame.makeBridge(5); -// //then -// -// } -//} \ No newline at end of file diff --git a/src/test/java/PointTest.java b/src/test/java/PointTest.java deleted file mode 100644 index 3a83228..0000000 --- a/src/test/java/PointTest.java +++ /dev/null @@ -1,21 +0,0 @@ -import org.junit.Test; - -import static org.junit.Assert.*; - -public class PointTest { - - @Test - public void 오른쪽_연결된_포인트_생성하기() { - assertEquals(Point.createRightLinkedPoint(1).getLinkedType(),LinkedType.RIGHT); - } - - @Test - public void 왼쪽_연결된_포인트_생성하기() { - assertEquals(Point.createLeftLinkedPoint(2).getLinkedType(),LinkedType.LEFT); - } - - @Test - public void 연결안된_포인트_생성하기() { - assertEquals(Point.createNotLinkedPoint(1).getLinkedType(),LinkedType.NONE); - } -} \ No newline at end of file diff --git a/src/test/java/domain/converter/OutputConverterTest.java b/src/test/java/domain/converter/OutputConverterTest.java new file mode 100644 index 0000000..11e8ed7 --- /dev/null +++ b/src/test/java/domain/converter/OutputConverterTest.java @@ -0,0 +1,18 @@ +package domain.converter; + +import domain.ladder.Ladder; +import dto.GameStartOption; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class OutputConverterTest { + + @Test + public void Height에_따른_Level_생성() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 10, "꽝,5000,꽝,3000"); + Ladder ladder = Ladder.of(gameStartOption); + + assertEquals(OutputConverter.of(ladder).getRows().size(), 10); + } +} \ No newline at end of file diff --git a/src/test/java/domain/converter/RowTest.java b/src/test/java/domain/converter/RowTest.java new file mode 100644 index 0000000..b153ea4 --- /dev/null +++ b/src/test/java/domain/converter/RowTest.java @@ -0,0 +1,40 @@ +package domain.converter; + +import domain.ladder.Ladder; +import dto.GameStartOption; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class RowTest { + + @Test + public void location에_맞는_bridge_point_생성() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 4, "꽝,5000,꽝,3000"); + Ladder ladder = Ladder.of(gameStartOption); + + Row row = Row.of(1, ladder); + + for (Point point : row.getPoints()) { + if (!point.isBlankPoint()) { + assertEquals((int) point.getBridge().getLocation(), 1); + } + } + } + + @Test + public void point와_bridge_Pillar_대응_확인() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 4, "꽝,5000,꽝,3000"); + Ladder ladder = Ladder.of(gameStartOption); + + Row row = Row.of(1, ladder); + + for (Point point : row.getPoints()) { + if (!point.isBlankPoint()) { + Integer pointPillarNum = point.getPillarNum(); + boolean levelBridgesIsPresent = ladder.getPillarByNum(pointPillarNum).getLevelBridges(1).isPresent(); + assertEquals(true, levelBridgesIsPresent); + } + } + } +} diff --git a/src/test/java/domain/factory/PillarFactoryTest.java b/src/test/java/domain/factory/PillarFactoryTest.java new file mode 100644 index 0000000..dc2e7a0 --- /dev/null +++ b/src/test/java/domain/factory/PillarFactoryTest.java @@ -0,0 +1,56 @@ +package domain.factory; + +import domain.ladder.Pillar; +import dto.GameStartOption; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PillarFactoryTest { + + + @Test + public void 첫번째기둥_넘버만들기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 10, "꽝,5000,꽝,3000"); + + PillarFactory pillarFactory = new PillarFactory(); + Pillar p = pillarFactory.createFirstPillar(gameStartOption); + assertEquals((Integer) 0, p.getPillarNum()); + } + + @Test + public void 가운데기둥_넘버만들기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 10, "꽝,5000,꽝,3000"); + + PillarFactory pillarFactory = new PillarFactory(); + Pillar p = pillarFactory.createFirstPillar(gameStartOption); + Pillar p1 = pillarFactory.createNotFirstPillar(gameStartOption, p); + + assertEquals((Integer) 1, p1.getPillarNum()); + } + + @Test + public void 마지막기둥_넘버만들기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 10, "꽝,5000,꽝,3000"); + + PillarFactory pillarFactory = new PillarFactory(); + Pillar p = pillarFactory.createFirstPillar(gameStartOption); + Pillar p1 = pillarFactory.createNotFirstPillar(gameStartOption, p); + Pillar p2 = pillarFactory.createNotFirstPillar(gameStartOption, p1); + Pillar p3 = pillarFactory.createNotFirstPillar(gameStartOption, p2); + + assertEquals((Integer) 3, p3.getPillarNum()); + } + + @Test + public void 이전기둥확인해서_넘버만들기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 10, "꽝,5000,꽝,3000"); + + PillarFactory pillarFactory = new PillarFactory(); + Pillar p = pillarFactory.createFirstPillar(gameStartOption); + Pillar p1 = pillarFactory.createNotFirstPillar(gameStartOption, p); + + assertEquals((Integer) 1, p1.getPillarNum()); + } + +} \ No newline at end of file diff --git a/src/test/java/domain/ladder/BridgeTest.java b/src/test/java/domain/ladder/BridgeTest.java new file mode 100644 index 0000000..fb60974 --- /dev/null +++ b/src/test/java/domain/ladder/BridgeTest.java @@ -0,0 +1,22 @@ +package domain.ladder; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class BridgeTest { + + @Test + public void 오른쪽_기둥_연결_bridge_생성하기() { + Bridge bridge = Bridge.of(1, LinkedType.RIGHT); + assertEquals(LinkedType.RIGHT, bridge.getLinkPillarDirection()); + } + + @Test + public void 왼쪽_기둥_연결_bridge_생성하기() { + Bridge bridge = Bridge.of(1, LinkedType.LEFT); + assertEquals(LinkedType.LEFT, bridge.getLinkPillarDirection()); + } + + +} \ No newline at end of file diff --git a/src/test/java/domain/ladder/LadderTest.java b/src/test/java/domain/ladder/LadderTest.java new file mode 100644 index 0000000..095c064 --- /dev/null +++ b/src/test/java/domain/ladder/LadderTest.java @@ -0,0 +1,26 @@ +package domain.ladder; + +import dto.GameStartOption; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class LadderTest { + + @Test + public void Ladder_생성하기_Pillar_리스트_생성하기() { + GameStartOption gameStartOption = new GameStartOption("pobi,honux,crong,jk", 4, "꽝,5000,꽝,3000"); + Ladder ladder = Ladder.of(gameStartOption); + + assertEquals((int) ladder.getWidth(), ladder.getPillars().size()); + } + + @Test + public void Pillar_NUM_에따라_찾기() { + GameStartOption gameStartOption = new GameStartOption("pobi,honux,crong,jk", 4, "꽝,5000,꽝,3000"); + Ladder ladder = Ladder.of(gameStartOption); + + Pillar p = ladder.getPillarByNum(1); + assertEquals((Integer) 1, p.getPillarNum()); + } +} \ No newline at end of file diff --git a/src/test/java/domain/ladder/PillarTest.java b/src/test/java/domain/ladder/PillarTest.java new file mode 100644 index 0000000..360a1ce --- /dev/null +++ b/src/test/java/domain/ladder/PillarTest.java @@ -0,0 +1,34 @@ +package domain.ladder; + + +import domain.maker.PillarMaker; +import dto.GameStartOption; +import org.junit.Test; + +import java.util.List; + +import static org.junit.Assert.assertEquals; + +public class PillarTest { + + @Test + public void 기둥에_연결된_다리의_location_값_리스트_가져오기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 3, "꽝,5000,꽝,3000"); + + Pillar p = Pillar.of(PillarMaker.of().createBridgesInThisPillar(gameStartOption), 1); + List bridgesLocations = p.getBridgesLocations(); + System.out.println(bridgesLocations); + assertEquals(true, bridgesLocations.size() <= 3 && bridgesLocations.size() >= 0); + } + + @Test + public void 기둥에_연결된_특정_방향의_다리의_location_값_리스트_가져오기() { + + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 3, "꽝,5000,꽝,3000"); + + Pillar p = Pillar.of(PillarMaker.of().createBridgesInThisPillar(gameStartOption), 1); + List bridgesLocations = p.getBridgesDirectionLocation(LinkedType.LEFT); + assertEquals(0, bridgesLocations.size()); + } + +} \ No newline at end of file diff --git a/src/test/java/domain/ladderCalculator/LadderIOTest.java b/src/test/java/domain/ladderCalculator/LadderIOTest.java new file mode 100644 index 0000000..dde3589 --- /dev/null +++ b/src/test/java/domain/ladderCalculator/LadderIOTest.java @@ -0,0 +1,18 @@ +package domain.ladderCalculator; + +import domain.ladder.Ladder; +import dto.GameStartOption; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class LadderIOTest { + + @Test + public void 유저_리스트_관리하는_유저_관리자_생성하기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 4, "꽝,5000,꽝,3000"); + Ladder ladder = Ladder.of(gameStartOption); + LadderIO ladderIO = LadderIO.of(gameStartOption); + assertEquals(4, ladderIO.getUsers().size()); + } +} \ No newline at end of file diff --git a/src/test/java/domain/maker/LadderMakerTest.java b/src/test/java/domain/maker/LadderMakerTest.java new file mode 100644 index 0000000..6a7cbfd --- /dev/null +++ b/src/test/java/domain/maker/LadderMakerTest.java @@ -0,0 +1,21 @@ +package domain.maker; + +import domain.ladder.Pillar; +import dto.GameStartOption; +import org.junit.Test; + +import java.util.List; + +import static org.junit.Assert.assertEquals; + +public class LadderMakerTest { + + @Test + public void LadderMaker로_Ladder안에있는_PillarList_만들기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 3, "꽝,5000,꽝,3000"); + + LadderMaker ladderMaker = LadderMaker.of(); + List pillarList = ladderMaker.createLadder(gameStartOption); + assertEquals(4, pillarList.size()); + } +} \ No newline at end of file diff --git a/src/test/java/domain/maker/PillarMakerTest.java b/src/test/java/domain/maker/PillarMakerTest.java new file mode 100644 index 0000000..d075f09 --- /dev/null +++ b/src/test/java/domain/maker/PillarMakerTest.java @@ -0,0 +1,91 @@ +package domain.maker; + +import domain.factory.PillarFactoryTest; +import domain.ladder.Bridge; +import domain.ladder.LinkedType; +import domain.ladder.Pillar; +import dto.GameStartOption; +import org.junit.Test; + +import java.util.List; + +import static org.junit.Assert.assertEquals; + +public class PillarMakerTest { + + @Test + public void 자동으로_오른쪽_기둥과_연결된_다리리스트_만들기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 3, "꽝,5000,꽝,3000"); + + List bridges = PillarMaker.of().createBridgesInThisPillar(gameStartOption); + assertEquals(true, bridges.size() <= 3); + } + + @Test + public void 첫번째_기둥_bridge_리스트_만들기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 3, "꽝,5000,꽝,3000"); + + List bridges = PillarMaker.of().createBridgesInThisPillar(gameStartOption); + + Pillar p = Pillar.of(bridges, 0); + + System.out.println(p.getBridgesLocations()); + + assertEquals(p.getBridgesDirectionLocation(LinkedType.RIGHT), p.getBridgesLocations()); + assertEquals(0, p.getBridgesDirectionLocation(LinkedType.LEFT).size()); + } + + @Test + public void 두번째_기둥_bridge_리스트_만들기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 10, "꽝,5000,꽝,3000"); + + + List bridges = PillarMaker.of().createBridgesInThisPillar(gameStartOption); + Pillar p = Pillar.of(bridges, 0); + + List bridges1 = PillarMaker.of().createBridgesInThisPillar(gameStartOption, p); + Pillar p1 = Pillar.of(bridges1, 1); + + List p1LeftBridgesLocation = p1.getBridgesDirectionLocation(LinkedType.LEFT); + List p1RightBridgesLocation = p1.getBridgesDirectionLocation(LinkedType.RIGHT); + List pRightBridgesLocation = p.getBridgesDirectionLocation(LinkedType.RIGHT); + + System.out.println("P RIGHT" + pRightBridgesLocation); + System.out.println("p1 LEFT" + p1LeftBridgesLocation); + System.out.println("p1 RIGHT" + p1RightBridgesLocation); + + assertEquals(p.getBridgesLocations(), p1LeftBridgesLocation); + assertEquals(pRightBridgesLocation, p1LeftBridgesLocation); + assertEquals(false, p1RightBridgesLocation.contains(p1LeftBridgesLocation)); + } + + @Test + public void 마지막_기둥_bridge_리스트_만들기() { + GameStartOption gameStartOption = GameStartOption.of("pobi,honux,crong,jk", 3, "꽝,5000,꽝,3000"); + + + List bridges = PillarMaker.of().createBridgesInThisPillar(gameStartOption); + Pillar p = Pillar.of(bridges, 0); + + List bridges1 = PillarMaker.of().createBridgesInThisPillar(gameStartOption, p); + Pillar p1 = Pillar.of(bridges1, 1); + + + List bridges2 = PillarMaker.of().createBridgesInThisPillar(gameStartOption, p1); + Pillar p2 = Pillar.of(bridges2, 2); + + List bridges3 = PillarMaker.of().createBridgesInThisPillar(gameStartOption, p2); + Pillar p3 = Pillar.of(bridges3, 3); + + + System.out.println("P RIGHT" + p.getBridgesDirectionLocation(LinkedType.RIGHT)); + System.out.println("p1 LEFT" + p1.getBridgesDirectionLocation(LinkedType.LEFT)); + System.out.println("p1 RIGHT" + p1.getBridgesDirectionLocation(LinkedType.RIGHT)); + System.out.println("p2 LEFT" + p2.getBridgesDirectionLocation(LinkedType.LEFT)); + System.out.println("p2 RIGHT" + p2.getBridgesDirectionLocation(LinkedType.RIGHT)); + System.out.println("p3 LEFT" + p3.getBridgesDirectionLocation(LinkedType.LEFT)); + + assertEquals(p3.getBridgesLocations(), p3.getBridgesDirectionLocation(LinkedType.LEFT)); + assertEquals(0, p3.getBridgesDirectionLocation(LinkedType.RIGHT).size()); + } +} \ No newline at end of file diff --git a/src/test/java/domain/user/ParticipantUsersTest.java b/src/test/java/domain/user/ParticipantUsersTest.java new file mode 100644 index 0000000..d35c5da --- /dev/null +++ b/src/test/java/domain/user/ParticipantUsersTest.java @@ -0,0 +1,16 @@ +package domain.user; + +import dto.GameStartOption; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class ParticipantUsersTest { + + @Test + public void 유저_리스트_관리하는_유저_관리자_생성하기() { + GameStartOption gameStartOption = new GameStartOption("pobi,honux,crong,jk", 4); + ParticipantUsers participantUsers = new ParticipantUsers(gameStartOption); + assertEquals(4, participantUsers.getUsers().size()); + } +} \ No newline at end of file diff --git a/src/test/java/domain/user/UserTest.java b/src/test/java/domain/user/UserTest.java new file mode 100644 index 0000000..4eef335 --- /dev/null +++ b/src/test/java/domain/user/UserTest.java @@ -0,0 +1,13 @@ +package domain.user; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class UserTest { + @Test + public void 유저생성() { + User user = new User("hello"); + assertEquals("hello", user.getName()); + } +} \ No newline at end of file diff --git a/src/test/java/util/UtilTest.java b/src/test/java/util/UtilTest.java new file mode 100644 index 0000000..5bafdfb --- /dev/null +++ b/src/test/java/util/UtilTest.java @@ -0,0 +1,24 @@ +package util; + +import org.junit.Test; + +import java.util.List; + +import static org.junit.Assert.assertEquals; + +public class UtilTest { + + @Test + public void 랜덤_정수_리스트_생성() { + List b = RandomIntegerMaker.createRandomIntegers(3); + assertEquals(true, b.size() <= 3 && b.size() >= 0); + } + + + @Test + public void UserName_여러개로_분리하기() { + String users = "pobi,honux,crong,jk"; + List separateUserName = RandomIntegerMaker.separateByDelimiter(users); + assertEquals("pobi", separateUserName.get(0)); + } +} \ No newline at end of file diff --git a/src/test/java/view/InputViewTest.java b/src/test/java/view/InputViewTest.java new file mode 100644 index 0000000..1d88452 --- /dev/null +++ b/src/test/java/view/InputViewTest.java @@ -0,0 +1,26 @@ +package view; + +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; + +import static org.junit.Assert.assertEquals; + +public class InputViewTest { + @Test + public void 참가자_입력() { + String purchase = "pobi,honux,crong,jk"; + InputStream purchaseInputStream = new ByteArrayInputStream(purchase.getBytes()); + InputView inputView = InputView.of(purchaseInputStream); + assertEquals("pobi,honux,crong,jk", inputView.participants()); + } + + @Test + public void 사다리_높이_입력() { + String ladderHeight = "1"; + InputStream inputCorrectStringStream = new ByteArrayInputStream(ladderHeight.getBytes()); + InputView inputView = InputView.of(inputCorrectStringStream); + assertEquals(1, inputView.ladderHeight()); + } +} \ No newline at end of file