자동차경주/제훈/step1

build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'eclipse'
 
 group = 'camp.nextstep'
 version = '1.0.0'
-sourceCompatibility = '1.8'
+sourceCompatibility = "11"
 
 repositories {
 	mavenCentral()
@@ -17,3 +17,4 @@ dependencies {
 test {
 	useJUnitPlatform()
 }
+targetCompatibility = JavaVersion.VERSION_11

src/main/java/study/racingcar/RacingCarApplication.java

@@ -0,0 +1,10 @@
+package study.racingcar;
+
+import study.racingcar.controller.CarController;
+
+public class RacingCarApplication {
+
+    public static void main(String[] args) {
+        new CarController();
+    }
+}

src/main/java/study/racingcar/controller/CarController.java

@@ -0,0 +1,38 @@
+package study.racingcar.controller;
+
+import study.racingcar.view.InputView;
+import study.racingcar.view.ResultView;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static study.racingcar.model.Car.requestCarsToMove;
+
+public class CarController {
+    public CarController() {
+        raceStart(InputView.getCarNumber(), InputView.getAttemptNumber());
+    }
+
+    public static List<Integer> raceStart(int carNum, int attemptNum) {
+        List<Integer> startLine = addCar(carNum);
+        List<Integer> finalPositions = new ArrayList<>();
+
+        for (int i = 0; i < attemptNum; i++) {
+            List<Integer> racingCar = requestCarsToMove(carNum, startLine);
+            ResultView.printRaceResult(racingCar);
+            System.out.println("");
+            finalPositions = new ArrayList<>(racingCar);
+        }
+        return finalPositions;
+    }
+
+    private static List<Integer> addCar(int carNum) {
+        List<Integer> positions = new ArrayList<>();
+
+        for (int i = 0; i < carNum; i++) {
+            positions.add(i,0);
+        }
+
+        return positions;
+    }
+}

src/main/java/study/racingcar/model/Car.java

@@ -0,0 +1,28 @@
+package study.racingcar.model;
+
+import java.util.List;
+import java.util.Random;
+
+public class Car {
+    private static final int MAX_BOUNDARY_OF_RANDOM_NUMBER= 10;
+    public Car() { }
+
+    public static List<Integer> requestCarsToMove(int carNum, List<Integer> positions) {
+        for (int i = 0; i < carNum; i++) {
+            forwardNumber(i, positions);
+        }
+        return positions;
+    }
+
+    private static void forwardNumber(int current, List<Integer> positions) {
+        Random random = new Random();
+        int forward = random.nextInt(MAX_BOUNDARY_OF_RANDOM_NUMBER); // 0부터 9
+
+        if (forward >= 4) {
+            int currentValue = positions.get(current);
+            int newValue = currentValue + 1;
+
+            positions.set(current, newValue);
+        }
+    }
+}

src/main/java/study/racingcar/view/InputView.java

@@ -0,0 +1,24 @@
+package study.racingcar.view;
+
+import java.util.Scanner;
+
+public class InputView {
+    public static int getCarNumber() {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.println("자동차 대수는 몇 대 인가요?");
+        int carNum = scanner.nextInt();
+
+        return carNum;
+    }
+
+    public static int getAttemptNumber() {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.println("시도할 횟수는 몇 회인가요?");
+        int attemptNum = scanner.nextInt();
+        System.out.println();
+
+        return attemptNum;
+    }
+}

src/main/java/study/racingcar/view/ResultView.java

@@ -0,0 +1,14 @@
+package study.racingcar.view;
+
+import java.util.List;
+
+public class ResultView {
+    public static void printRaceResult(List<Integer> positions) {
+        for (int pos : positions) {
+            for (int k = 0; k < pos; k++) {
+                System.out.print("ㅡ");
+            }
+            System.out.println();
+        }
+    }
+}

src/main/java/study/stringcalculator/StringCalculator.java

@@ -0,0 +1,36 @@
+package study.stringcalculator;
+
+import java.util.List;
+
+public class StringCalculator {
+
+    private StringCalculator() { }
+    public static int calculate(String text) {
+        List<String> values = StringParser.parse(text);
+        int number = Integer.parseInt(values.get(0));
+
+        for (int i = 1; i < values.size(); i += 2) {
+
+            int operand = Integer.parseInt(values.get(i + 1));
+            String operator = values.get(i);
+
+            number = getNumber(number, operand, operator);
+        }
+
+        return number;
+    }
+
+    private static int getNumber(int number, int operand, String operator) {
+        if ("+".equals(operator)) return number + operand;
+        if ("-".equals(operator)) return number - operand;
+        if ("*".equals(operator)) return number * operand;
+        if ("/".equals(operator)) {
+            if (operand == 0) {
+                throw new IllegalArgumentException();
+            }
+            return number / operand;
+        }
+
+        throw new IllegalArgumentException("잘못된 연산자 입니다.");
+    }
+}

src/main/java/study/stringcalculator/StringParser.java

@@ -0,0 +1,14 @@
+package study.stringcalculator;
+
+import java.util.List;
+
+public class StringParser {
+
+    private StringParser() { }
+
+    static List<String> parse(String input) {
+        return List.of(input.split(" "));
+        // 알아둘 것. ArrayList로 만들면 가변 + null값 허용
+        // List.of 메서드로 만들면 불변 + null값은 허용 X
+    }
+}

src/test/java/study/exam/SetTest.java

@@ -0,0 +1,84 @@
+package study.exam;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class SetTest {
+    private Set<Integer> numbers;
+
+    @BeforeEach
+    @DisplayName("HashSet에 값을 추가한다.")
+    void setUp() {
+        numbers = new HashSet<>();
+        numbers.add(1);
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+    }
+
+    @Test
+    @DisplayName("집합의 크기를 확인할 수 있다.")
+    void setSize() {
+        int result = numbers.size();
+        assertEquals(result, 3); // Set은 중복을 허용하지 않는다.
+    }
+
+    @Test
+    @DisplayName("집합에 값이 포함되어있는지 비교할 수 있다.")
+    void compareContains() {
+        numbers = new HashSet<>();
+
+        numbers.add(1);
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+
+        assertThat(numbers.contains(1)).isTrue();
+        assertThat(numbers.contains(2)).isTrue();
+        assertThat(numbers.contains(3)).isTrue();
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {1, 2, 3})
+    @DisplayName("ValueSource를 사용해 입력 받은 숫자가 각각 numbers에 포함되는지 확인한다.")
+    void compareContains(int value) {
+        numbers = new HashSet<>();
+
+        numbers.add(1);
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+
+        assertThat(numbers.contains(value)).isTrue();
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "1, true",
+            "2, true",
+            "3, true",
+            "4, false",
+            "5, false"
+    })
+    @DisplayName("CsvSource로 true 값만 비교하는 것이 아닌 false 값도 비교할 수 있다.")
+    void compareContains(int value, boolean expected) {
+        numbers = new HashSet<>();
+
+        numbers.add(1);
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+
+        assertThat(numbers.contains(value)).isEqualTo(expected);
+    }
+}

src/test/java/study/exam/StringTest.java

@@ -0,0 +1,47 @@
+package study.exam;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class StringTest {
+    @Test
+    @DisplayName("abc에서 b를 d로 대체했을 때 같은지 테스트하는 코드")
+    void replace() {
+        String actual = "abc".replace("b", "d");
+        assertThat(actual).isEqualTo("adc");
+    }
+    // 요구사항 1
+    @Test
+    @DisplayName("특정 문자열로 분리하는 테스트 코드")
+    public void split() {
+        String[] values = "1,2".split(",");
+        assertThat(values).containsExactly("1", "2");
+        values = "1".split(",");
+        assertThat(values).contains("1");
+    }
+    @Test
+    @DisplayName("특정 문자열까지 읽어서 비교하는 테스트 코드")
+    public void subString() {
+        String input = "(1,2)";
+        String result = input.substring(1, input.length() - 1); //문자열 인덱스 1부터 input의 길이 - 1 즉 2까지.
+        assertThat(result).isEqualTo("1,2");
+    }
+    @Test
+    @DisplayName("String의 특정 위치의 문자 가져오기")
+    public void getIndexValue() {
+        String values = "abc";
+        assertEquals('a', values.charAt(0));
+    }
+
+    @Test
+    @DisplayName("위치 값을 벗어났을 때의 예외")
+    public void stringIndexOutOfBoundsException() {
+        String values = "abc";
+        assertThrows(StringIndexOutOfBoundsException.class, () -> values.charAt(-1));
+        assertThrows(StringIndexOutOfBoundsException.class, () -> values.charAt(3));
+    }
+}

src/test/java/study/racingcar/CarTest.java

@@ -0,0 +1,46 @@
+package study.racingcar;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static study.racingcar.controller.CarController.raceStart;
+import static study.racingcar.model.Car.requestCarsToMove;
+
+public class CarTest {
+
+    private static final int MAX_BOUNDARY_OF_RANDOM_CAR_NUMBER = 5;
+    private static final int MAX_BOUNDARY_OF_RANDOM_ATTEMPT_NUMBER = 3;
+    @Test
+    public void 자동차_이동_로직을_확인한다() {
+        // given
+        Random random = new Random();
+        int carNum = random.nextInt(MAX_BOUNDARY_OF_RANDOM_CAR_NUMBER + 1); // 1 ~ 5
+        int attemptNum = random.nextInt(MAX_BOUNDARY_OF_RANDOM_ATTEMPT_NUMBER + 3); // 3 ~ 5
+
+        // when
+        List<Integer> finalPositions = raceStart(carNum, attemptNum);
+
+        // then
+        assertEquals(carNum, finalPositions.size());
+    }
+
+    @Test
+    public void 자동차_전진_로직을_확인한다() {
+        // given
+        Random random = new Random();
+        int carNum = random.nextInt(MAX_BOUNDARY_OF_RANDOM_CAR_NUMBER + 1); // 1 ~ 5
+        List<Integer> positions = new ArrayList<>();
+
+        // when
+        List<Integer> checkForward = requestCarsToMove(carNum, positions);
+
+        // then
+        for (int i = 0 ; i < carNum; i++) {
+            assertEquals(checkForward.get(i) == 0 || checkForward.get(i) == 1, true);
+        }
+    }
+}