diff --git a/.idea/misc.xml b/.idea/misc.xml index 8f86b33..32cf4db 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -4,7 +4,7 @@ - + \ No newline at end of file diff --git a/.idea/uiDesigner.xml b/.idea/uiDesigner.xml new file mode 100644 index 0000000..2b63946 --- /dev/null +++ b/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/main/java/Ladder.java b/src/main/java/Ladder.java deleted file mode 100644 index 0d2b070..0000000 --- a/src/main/java/Ladder.java +++ /dev/null @@ -1,8 +0,0 @@ -public class Ladder { - - private final int[][] rows; - - public Ladder(int row, int numberOfPerson) { - rows = new int[row][numberOfPerson]; - } -} diff --git a/src/main/java/ladder/Direction.java b/src/main/java/ladder/Direction.java new file mode 100644 index 0000000..614662c --- /dev/null +++ b/src/main/java/ladder/Direction.java @@ -0,0 +1,15 @@ +package ladder; + +public enum Direction { + LEFT(-1), RIGHT(1), NONE(0); + + private final int value; + + Direction(int value) { + this.value = value; + } + + public int getValue() { + return value; + } +} diff --git a/src/main/java/ladder/ExceptionMessage.java b/src/main/java/ladder/ExceptionMessage.java new file mode 100644 index 0000000..8ff7aae --- /dev/null +++ b/src/main/java/ladder/ExceptionMessage.java @@ -0,0 +1,20 @@ +package ladder; + +public enum ExceptionMessage { + + INVALID_LADDER_POSITION("사다리 위치는 1이상 자연수입니다."), + INVALID_LADDER_NUMBER("사다리의 행과 열은 2 이상이어야 합니다."), + INVALID_POSITION("유효하지 않은 위치입니다."), + INVALID_DRAW_POSITION("사다리를 그릴 수 없는 위치입니다."), + INVALID_NATURAL_NUMBER("자연수가 아닙니다."); + + private final String message; + + ExceptionMessage(String message) { + this.message = message; + } + + public String getMessage() { + return message; + } +} diff --git a/src/main/java/ladder/GreaterThanOne.java b/src/main/java/ladder/GreaterThanOne.java new file mode 100644 index 0000000..bc1021d --- /dev/null +++ b/src/main/java/ladder/GreaterThanOne.java @@ -0,0 +1,26 @@ +package ladder; + +public class GreaterThanOne { + + private final int number; + + private GreaterThanOne(int number) { + this.number = number; + } + + public static GreaterThanOne from(int number) { + if (!isGreaterThanOne(number)) { + throw new IllegalArgumentException(ExceptionMessage.INVALID_LADDER_NUMBER.getMessage()); + } + + return new GreaterThanOne(number); + } + + private static boolean isGreaterThanOne(int number) { + return number > 1; + } + + public int getNumber() { + return number; + } +} diff --git a/src/main/java/ladder/LadderGame.java b/src/main/java/ladder/LadderGame.java new file mode 100644 index 0000000..fe194e2 --- /dev/null +++ b/src/main/java/ladder/LadderGame.java @@ -0,0 +1,20 @@ +package ladder; + +import ladder.creator.LadderCreator; + +public class LadderGame { + + private final LadderCreator ladderCreator; + + public LadderGame(LadderCreator ladderCreator) { + this.ladderCreator = ladderCreator; + } + +// 사다리에 position값을 넣어주고 반복문을 통해 +// 메세지를 보내면서 다음 좌표가 어딨는지 질문을 함 + public int run(Position position) { + LadderRunner ladderRunner = new LadderRunner(ladderCreator.getRows()); + ladderRunner.run(position); + return position.getPosition(); + } +} diff --git a/src/main/java/ladder/LadderGameFactory.java b/src/main/java/ladder/LadderGameFactory.java new file mode 100644 index 0000000..d924f07 --- /dev/null +++ b/src/main/java/ladder/LadderGameFactory.java @@ -0,0 +1,14 @@ +package ladder; + +import ladder.creator.AutoLadderCreator; +import ladder.creator.LadderCreator; + +public class LadderGameFactory { + + private static LadderCreator ladderCreator; + + public static LadderGame createRandomLadderGame(LadderSize ladderSize) { + AutoLadderCreator autoLadderCreator = new AutoLadderCreator(ladderSize.getNumberOfRow(), ladderSize.getNumberOfPerson()); + return new LadderGame(autoLadderCreator); + } +} diff --git a/src/main/java/ladder/LadderPosition.java b/src/main/java/ladder/LadderPosition.java new file mode 100644 index 0000000..b4ced69 --- /dev/null +++ b/src/main/java/ladder/LadderPosition.java @@ -0,0 +1,11 @@ +package ladder; + +public class LadderPosition { + private final int row; + private final int col; + + public LadderPosition(int row, int col) { + this.row = row; + this.col = col; + } +} diff --git a/src/main/java/ladder/LadderRunner.java b/src/main/java/ladder/LadderRunner.java new file mode 100644 index 0000000..f1b98fe --- /dev/null +++ b/src/main/java/ladder/LadderRunner.java @@ -0,0 +1,41 @@ +package ladder; + +public class LadderRunner { + + private final Row[] rows; + + public LadderRunner(Row[] rows) { + this.rows = rows; + } + + public int run(Position position) { + for (int i = 0; i < rows.length; i++) { + // Before 출력 + System.out.println("Before"); + printLadder(position, i); // 사다리 상태 출력 + System.out.println(); + + // 현재 행에서 위치 이동 (왼쪽 또는 오른쪽으로) + rows[i].nextPosition(position); + + // After 출력 + System.out.println("After"); + printLadder(position, i); // 사다리 상태 출력 + System.out.println(); + } + + return position.getPosition(); + } + + // 사다리 상태를 출력하는 메서드 + private void printLadder(Position position, int currentRow) { + for (int i = 0; i < rows.length; i++) { + if (currentRow == i) { + rows[i].printUserRow(position); // 사용자 위치를 표시하여 출력 + } else { + rows[i].printRow(); // 일반 행 출력 + } + } + } + +} diff --git a/src/main/java/ladder/LadderSize.java b/src/main/java/ladder/LadderSize.java new file mode 100644 index 0000000..8cb1d5f --- /dev/null +++ b/src/main/java/ladder/LadderSize.java @@ -0,0 +1,25 @@ +package ladder; + +public class LadderSize { + private final GreaterThanOne numberOfRow; + private final GreaterThanOne numberOfPerson; + private static final double LINE_PROBABILITY = 0.3; + + public LadderSize(GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson) { + this.numberOfRow = numberOfRow; + this.numberOfPerson = numberOfPerson; + } + + public GreaterThanOne getNumberOfRow() { + return numberOfRow; + } + + public GreaterThanOne getNumberOfPerson() { + return numberOfPerson; + } + + public int calculateNumberOfLines() { + // 사다리 행 * 열 * 0.3에 해당하는 라인의 수 계산 + return (int) (numberOfRow.getNumber() * numberOfPerson.getNumber() * LINE_PROBABILITY); + } +} diff --git a/src/main/java/ladder/Node.java b/src/main/java/ladder/Node.java new file mode 100644 index 0000000..a802af4 --- /dev/null +++ b/src/main/java/ladder/Node.java @@ -0,0 +1,61 @@ +package ladder; + +import static ladder.Direction.*; + +public class Node { + + private Direction direction; + + private Node(Direction direction) { + this.direction = direction; + } + + public static Node from(Direction direction) { + return new Node(direction); + } + + public void setRightNode(Position position) { + direction = RIGHT; + } + + public void setLeftNode(Position position) { + direction = LEFT; + } + + public void move(Position position) { + + if (isRight()) { + position.next(); + return; + } + if (isLeft()) { + position.prev(); + return; + } + } + + public boolean isAlreadySetDirection() { + return !isNone(); + } + + private boolean isRight() { + return direction == RIGHT; + } + + private boolean isLeft() { + return direction == LEFT; + } + + private boolean isNone() { + return direction == NONE; + } + + // 방향 값을 반환하는 메서드 + public int getDirectionValue() { + return switch (direction) { + case LEFT -> -1; + case RIGHT -> 1; + default -> 0; + }; + } +} diff --git a/src/main/java/ladder/Position.java b/src/main/java/ladder/Position.java new file mode 100644 index 0000000..ff1b76d --- /dev/null +++ b/src/main/java/ladder/Position.java @@ -0,0 +1,46 @@ +package ladder; + +public class Position { + + private int position; + + private Position(int position) { + this.position = position; + } + + public int getPosition() { + return position; + } + + public static Position from(int position) { + validatePosition(position); + return new Position(position); + } + + public boolean isBiggerThan(int position) { + return this.position > position; + } + + public boolean isSmallerThan(int position) { + return this.position < position; + } + + public void next() { + position++; + } + + public void prev() { + position--; + } + + + private static void validatePosition(int position) { + if (!isPosition(position)) { + throw new IllegalArgumentException(ExceptionMessage.INVALID_LADDER_POSITION.getMessage()); + } + } + + private static boolean isPosition(int position) { + return position >= 0; + } +} diff --git a/src/main/java/ladder/Row.java b/src/main/java/ladder/Row.java new file mode 100644 index 0000000..f62314b --- /dev/null +++ b/src/main/java/ladder/Row.java @@ -0,0 +1,91 @@ +package ladder; + +import static ladder.Direction.*; + +public class Row { + + Node[] nodes; + + + public Row(GreaterThanOne numberOfPerson) { + nodes = new Node[numberOfPerson.getNumber()]; + + for (int i = 0; i < numberOfPerson.getNumber(); i++) { + nodes[i] = Node.from(NONE); + } + } + + public void drawLine(Position startPosition) { + validateDrawLinePosition(startPosition); + setDirectionBetweenNextPosition(startPosition); + } + + private void setDirectionBetweenNextPosition(Position position) { + nodes[position.getPosition()].setRightNode(position); + position.next(); + nodes[position.getPosition()].setLeftNode(position); + } + + // 자신의 상태가 무엇인지에 따라서 다음 좌표를 계산하고 반환을 함 + public void nextPosition(Position position) { + validatePosition(position); + + nodes[position.getPosition()].move(position); + } + + private void validatePosition(Position position) { + if (position.isBiggerThan(nodes.length - 1)) { + throw new IllegalArgumentException(ExceptionMessage.INVALID_POSITION.getMessage()); + } + } + + private void validateDrawLinePosition(Position startPosition) { + if (isInvalidPosition(startPosition) || isLineAtPosition(startPosition) || isLineAtNextPosition(startPosition)) { + throw new IllegalArgumentException(ExceptionMessage.INVALID_DRAW_POSITION.getMessage()); + } + } + + private boolean isInvalidPosition(Position startPosition) { + return startPosition.isBiggerThan(nodes.length - 1); + } + + private boolean isLineAtPosition(Position startPosition) { + return nodes[startPosition.getPosition()].isAlreadySetDirection(); + } + + private boolean isLineAtNextPosition(Position startPosition) { + startPosition.next(); + boolean isLineAtPosition = nodes[startPosition.getPosition()].isAlreadySetDirection(); + startPosition.prev(); + return isLineAtPosition; + } + + + // 한 행을 출력하는 메서드 (별 표시 없이) + public void printRow() { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < nodes.length; i++) { + sb.append(nodes[i].getDirectionValue()).append(" "); + } + System.out.println(sb); + } + + // 사용자 위치에 *를 표시하여 한 행을 출력하는 메서드 + public void printUserRow(Position position) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < nodes.length; i++) { + if (i == position.getPosition()) { + sb.append(nodes[i].getDirectionValue()).append("* "); + } else { + sb.append(nodes[i].getDirectionValue()).append(" "); + } + } + System.out.println(sb); + } + + public boolean canDrawLineAtPosition(Position position) { + return !isInvalidPosition(position) + && !isLineAtPosition(position) + && !isLineAtNextPosition(position); // 사전에 유효성 검사를 수행 + } +} \ No newline at end of file diff --git a/src/main/java/ladder/creator/AutoLadderCreator.java b/src/main/java/ladder/creator/AutoLadderCreator.java new file mode 100644 index 0000000..22789d7 --- /dev/null +++ b/src/main/java/ladder/creator/AutoLadderCreator.java @@ -0,0 +1,57 @@ +package ladder.creator; + +import ladder.*; + +import java.util.HashSet; +import java.util.Random; + +public class AutoLadderCreator implements LadderCreator { + + private final Row[] rows; + private Random random = new Random(); + + public AutoLadderCreator(GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson) { + rows = new Row[numberOfRow.getNumber()]; + + for (int i = 0; i < numberOfRow.getNumber(); i++) { + rows[i] = new Row(numberOfPerson); + } + } + + public void drawRandomLines(LadderSize ladderSize, GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson) { + int linesToCreate = ladderSize.calculateNumberOfLines(); + + HashSet positions = new HashSet<>(); + + + while (positions.size() < linesToCreate) { + int row = random.nextInt(numberOfRow.getNumber()); + int col = random.nextInt(numberOfPerson.getNumber() - 1); // 선이 열 사이에 있으므로 열 크기보다 1 작게 선택 + + LadderPosition newPosition = new LadderPosition(row, col); + + // 해당 위치에 선을 그릴 수 있는지 확인 + if (positions.contains(newPosition) || !canDrawLine(Position.from(row), Position.from(col))) { + continue; + } + + this.drawLine(Position.from(row), Position.from(col)); + positions.add(newPosition); + } + } + + // 선을 그릴 수 있는지 확인하는 메소드 + private boolean canDrawLine(Position row, Position col) { + return rows[row.getPosition()].canDrawLineAtPosition(col); // 유효성 검사 메소드를 호출 + } + + @Override + public void drawLine(Position row, Position col) { + rows[row.getPosition()].drawLine(col); + } + + @Override + public Row[] getRows() { + return rows; + } +} diff --git a/src/main/java/ladder/creator/DefaultLadderCreator.java b/src/main/java/ladder/creator/DefaultLadderCreator.java new file mode 100644 index 0000000..691af86 --- /dev/null +++ b/src/main/java/ladder/creator/DefaultLadderCreator.java @@ -0,0 +1,28 @@ +package ladder.creator; + +import ladder.GreaterThanOne; +import ladder.Position; +import ladder.Row; + +public class DefaultLadderCreator implements LadderCreator { + + private final Row[] rows; + + public DefaultLadderCreator(GreaterThanOne numberOfRow, GreaterThanOne numberOfPerson) { + rows = new Row[numberOfRow.getNumber()]; + + for (int i = 0; i < numberOfRow.getNumber(); i++) { + rows[i] = new Row(numberOfPerson); + } + } + + @Override + public void drawLine(Position row, Position col) { + rows[row.getPosition()].drawLine(col); + } + + @Override + public Row[] getRows() { + return rows; + } +} diff --git a/src/main/java/ladder/creator/LadderCreator.java b/src/main/java/ladder/creator/LadderCreator.java new file mode 100644 index 0000000..5af30ed --- /dev/null +++ b/src/main/java/ladder/creator/LadderCreator.java @@ -0,0 +1,11 @@ +package ladder.creator; + +import ladder.Position; +import ladder.Row; + +public interface LadderCreator { + + public void drawLine(Position row, Position col); + + public Row[] getRows(); +} diff --git a/src/test/java/LadderTest.java b/src/test/java/LadderTest.java deleted file mode 100644 index 741a915..0000000 --- a/src/test/java/LadderTest.java +++ /dev/null @@ -1,5 +0,0 @@ -import static org.junit.jupiter.api.Assertions.*; - -class LadderTest { - -} \ No newline at end of file diff --git a/src/test/java/ladder/LadderGameTest.java b/src/test/java/ladder/LadderGameTest.java new file mode 100644 index 0000000..ef876b0 --- /dev/null +++ b/src/test/java/ladder/LadderGameTest.java @@ -0,0 +1,71 @@ +package ladder; + +import ladder.creator.AutoLadderCreator; +import ladder.creator.DefaultLadderCreator; +import ladder.creator.LadderCreator; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.*; + +class LadderGameTest { + + @Test + void 사다리_생성_확인() { + //given + GreaterThanOne numberOfRow = GreaterThanOne.from(3); + GreaterThanOne numberOfPerson = GreaterThanOne.from(5); + + //when + LadderCreator ladderCreator = new DefaultLadderCreator(numberOfRow, numberOfPerson); + + //then + assertThat(ladderCreator).isNotNull(); + } + + @Test + void 사다리_사람_예외_처리_확인() { + //when + GreaterThanOne row = GreaterThanOne.from(2); + GreaterThanOne numberOfPerson = GreaterThanOne.from(3); + LadderCreator ladderCreator = new DefaultLadderCreator(row, numberOfPerson); + LadderRunner ladderRunner = new LadderRunner(ladderCreator.getRows()); + + //given + Position nthOfPerson = Position.from(4); + + //then + assertThatThrownBy(() -> ladderRunner.run(nthOfPerson)) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 사다리_결과_확인() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(4); + GreaterThanOne row = GreaterThanOne.from(3); + LadderCreator ladderCreator = new DefaultLadderCreator(row, numberOfPerson); + LadderRunner ladderRunner = new LadderRunner(ladderCreator.getRows()); + + ladderCreator.drawLine(Position.from(0),Position.from(0)); + ladderCreator.drawLine(Position.from(1),Position.from(1)); + ladderCreator.drawLine(Position.from(2),Position.from(0)); + + //given + Position nthOfPerson = Position.from(0); + + //then + assertThat(ladderRunner.run(nthOfPerson)).isEqualTo(2); + + //given + nthOfPerson = Position.from(1); + + //then + assertThat(ladderRunner.run(nthOfPerson)).isEqualTo(1); + + //given + nthOfPerson = Position.from(2); + + //then + assertThat(ladderRunner.run(nthOfPerson)).isEqualTo(0); + } +} \ No newline at end of file diff --git a/src/test/java/ladder/NodeTest.java b/src/test/java/ladder/NodeTest.java new file mode 100644 index 0000000..db066e8 --- /dev/null +++ b/src/test/java/ladder/NodeTest.java @@ -0,0 +1,43 @@ +package ladder; + +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; + +import static ladder.Direction.*; +import static org.assertj.core.api.Assertions.*; + +public class NodeTest { + + @Test + void 오른쪽_방향_위치_이동_확인() { + Node node = Node.from(RIGHT); + + Position position = Position.from(0); + + node.move(position); + + assertThat(position.getPosition()).isEqualTo(1); + } + + @Test + void NONE_방향_위치_이동_확인() { + Node node = Node.from(NONE); + + Position position = Position.from(0); + + node.move(position); + + assertThat(position.getPosition()).isEqualTo(0); + } + + @Test + void 왼쪽_방향_위치_이동_확인() { + Node node = Node.from(LEFT); + + Position position = Position.from(1); + + node.move(position); + + assertThat(position.getPosition()).isEqualTo(0); + } +} diff --git a/src/test/java/ladder/RandomLadderGameTest.java b/src/test/java/ladder/RandomLadderGameTest.java new file mode 100644 index 0000000..8c3f9a6 --- /dev/null +++ b/src/test/java/ladder/RandomLadderGameTest.java @@ -0,0 +1,41 @@ +package ladder; + +import ladder.creator.AutoLadderCreator; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class RandomLadderGameTest { + + @Test + void 랜덤_사다리_생성_확인() { + //given + GreaterThanOne numberOfRow = GreaterThanOne.from(3); + GreaterThanOne numberOfPerson = GreaterThanOne.from(5); + + //when + AutoLadderCreator ladderCreator = new AutoLadderCreator(numberOfRow, numberOfPerson); + + //then + assertThat(ladderCreator).isNotNull(); + } + + @Test + void 랜덤_사다리_결과_확인() { + //given + GreaterThanOne numberOfRow = GreaterThanOne.from(3); + GreaterThanOne numberOfPerson = GreaterThanOne.from(5); + LadderSize ladderSize = new LadderSize(numberOfRow, numberOfPerson); + + AutoLadderCreator ladderCreator = new AutoLadderCreator(numberOfRow, numberOfPerson); + LadderRunner ladderRunner = new LadderRunner(ladderCreator.getRows()); + + //when + ladderCreator.drawRandomLines(ladderSize, numberOfRow, numberOfPerson); + + //then + ladderRunner.run(Position.from(0)); + + } + +} diff --git a/src/test/java/ladder/RowTest.java b/src/test/java/ladder/RowTest.java new file mode 100644 index 0000000..09d9004 --- /dev/null +++ b/src/test/java/ladder/RowTest.java @@ -0,0 +1,156 @@ +package ladder; + +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.*; + +class RowTest { + + @Test + void 한_칸_사다리_이동() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(2); + Row row = new Row(numberOfPerson); + + //given + Position position = Position.from(0); + row.nextPosition(position); + + //then + assertThat(position.getPosition()).isEqualTo(0); + } + + @Test + void 두_칸_사다리_선_이동() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(2); + Row row = new Row(numberOfPerson); + row.drawLine(Position.from(0)); + + //given + Position position = Position.from(0); + row.nextPosition(position); + + //then + assertThat(position.getPosition()).isEqualTo(1); + + //given + position = Position.from(1); + row.nextPosition(position); + + //then + assertThat(position.getPosition()).isEqualTo(0); + } + + @Test + void 세_칸_사다리_선_이동() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(3); + Row row = new Row(numberOfPerson); + row.drawLine(Position.from(0)); + + //given + Position position = Position.from(0); + row.nextPosition(position); + + //then + assertThat(position.getPosition()).isEqualTo(1); + + //given + position = Position.from(1); + row.nextPosition(position); + + //then + assertThat(position.getPosition()).isEqualTo(0); + + //given + position = Position.from(2); + row.nextPosition(position); + + //then + assertThat(position.getPosition()).isEqualTo(2); + } + + @Test + void 사다리_사람수_예외_처리() { + assertThatThrownBy(() -> new Row(GreaterThanOne.from(0))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 사다리_최대_사람수_초과_예외() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(3); + Row row = new Row(numberOfPerson); + + //given + + //then + assertThatThrownBy(() -> row.nextPosition(Position.from(3))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 사다리_최소_사람수_미만_예외() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(3); + Row row = new Row(numberOfPerson); + + //given + + //then + assertThatThrownBy(() -> row.nextPosition(Position.from(-1))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 사다리_그리기_위치_초과_예외() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(3); + Row row = new Row(numberOfPerson); + + //given + + //then + assertThatThrownBy(() -> row.drawLine(Position.from(3))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 사다리_그리기_위치_미만_예외() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(3); + Row row = new Row(numberOfPerson); + + //given + + //then + assertThatThrownBy(() -> row.drawLine(Position.from(-1))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 사다리_그리기_좌측_선_중복_예외() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(3); + Row row = new Row(numberOfPerson); + row.drawLine(Position.from(0)); + + //then + assertThatThrownBy(() -> row.drawLine(Position.from(1))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 사다리_그리기_우측_선_중복_예외() { + //when + GreaterThanOne numberOfPerson = GreaterThanOne.from(3); + Row row = new Row(numberOfPerson); + row.drawLine(Position.from(1)); + + //then + assertThatThrownBy(() -> row.drawLine(Position.from(0))) + .isInstanceOf(IllegalArgumentException.class); + + } +} \ No newline at end of file