숫자야구게임-단위테스트

src/main/java/study/calculator/Calculator.java

@@ -0,0 +1,19 @@
+package study.calculator;
+
+
+import java.util.List;
+
+class Calculator {
+
+    public static Double calculate(List<Object> input) {
+        double result = Double.parseDouble((String) input.get(0));
+
+        for (int i = 1; i < input.size(); i += 2) {
+            String operatorSymbol = input.get(i).toString();
+            Operator operator = Operator.getOperator(operatorSymbol);
+            double right = Double.parseDouble((String) input.get(i + 1));
+            result = operator.calculate(result, right);
+        }
+        return result;
+    }
+}

src/main/java/study/calculator/Expression.java

@@ -0,0 +1,21 @@
+package study.calculator;
+
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Expression {
+
+    private final String expression;
+
+    public Expression(String expression) {
+        this.expression = expression;
+    }
+
+    public List<Object> splitByBlank() {
+        return Arrays.stream(expression.split(" "))
+                .map(String::new)
+                .collect(Collectors.toList());
+    }
+}

src/main/java/study/calculator/Operator.java

@@ -0,0 +1,33 @@
+package study.calculator;
+
+
+import java.util.function.BinaryOperator;
+import java.util.stream.Stream;
+
+public enum Operator {
+    // enum 클래스를 사용해서 그 일에 대한 책임을 갖고 있는 객체가 상태(값)와 행위(로직)를 가질 수 있다.
+    PLUS("+", (left, right) -> left + right),
+    MINUS("-", (left, right) -> left - right),
+    MULTIPLY("*", (left, right) -> left * right),
+    DIVISION("/", (left, right) -> left / right);
+
+    private final BinaryOperator<Double> expression;
+    private final String symbol;
+
+    Operator(String symbol, BinaryOperator<Double> expression) {
+        this.symbol = symbol;
+        this.expression = expression;
+    }
+
+    public Double calculate(double left, double right) {
+        return expression.apply(left, right);
+    }
+
+    public static Operator getOperator(String symbol) {
+        return Stream.of(Operator.values())
+                .filter(op -> op.symbol.equals(symbol))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("Invalid operator symbol: " + symbol));
+    }
+
+}

src/test/java/study/SetTest.java

@@ -0,0 +1,72 @@
+package study;
+
+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.*;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+public class SetTest {
+    private Set<Integer> numbers;
+
+    @BeforeEach
+    void setUp() {
+        numbers = new HashSet<>();
+        numbers.add(1);
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+    }
+
+    // Test Case 구현
+    /* 요구사항 1)
+    -Set의 size() 메소드를 활용해 Set의 크기를 확인하는 학습테스트를 구현한다.
+    */
+    @Test
+    @DisplayName("set의 크기가 3인걸 확인한다.")
+    void size() {
+        assertThat(numbers).size().isEqualTo(3);
+        assertEquals(numbers.size(), 3);
+//        assertThat(numbers).size().isEqualTo(4); set은 중복을 허용하지 않는다.
+    }
+
+    /* 요구사항 2)
+    -Set의 contains() 메소드를 활용해 1, 2, 3의 값이 존재하는지를 확인하는 학습테스트를 구현하려한다.
+    -구현하고 보니 다음과 같이 중복 코드가 계속해서 발생한다.
+    -JUnit의 ParameterizedTest를 활용해 중복 코드를 제거해 본다.
+    */
+    @Test
+    @DisplayName("1,2,3 값이 존재한다.")
+    void contains() {
+        assertThat(numbers).contains(1);
+        assertThat(numbers.contains(2)).isTrue();
+        assertThat(numbers.contains(3)).isTrue();
+    }
+
+    @ParameterizedTest
+    @DisplayName("set 포함여부를 확인해 중복코드를 제거한다.")
+    @ValueSource(ints = {1, 2, 3, 4, 5})
+    void isContain(int input) {
+        assertThat(numbers.contains(input)).isTrue();
+    }
+
+    /* 요구사항 3)
+    -요구사항 2는 contains 메소드 결과 값이 true인 경우만 테스트 가능하다. 입력 값에 따라 결과 값이 다른 경우에 대한 테스트도 가능하도록 구현한다.
+    -예를 들어 1, 2, 3 값은 contains 메소드 실행결과 true, 4, 5 값을 넣으면 false 가 반환되는 테스트를 하나의 Test Case로 구현한다.
+    */
+    @ParameterizedTest
+    @CsvSource(value = {"1:true","2:true","3:true","4:false","5:false"}, delimiter = ':')
+    @DisplayName("4,5를 넣으면 실패한다.")
+    void toLowerCase_ShouldGenerateTheExpectedLowercaseValue(int input, boolean expected) {
+        assertThat(numbers.contains(input)).isEqualTo(expected);
+    }
+
+}

src/test/java/study/StringTest.java

@@ -1,13 +1,72 @@
 package study;
 
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
+
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
 
 public class StringTest {
     @Test
     void replace() {
         String actual = "abc".replace("b", "d");
         assertThat(actual).isEqualTo("adc");
     }
+    /* 요구사항 1)
+    -"1,2"을 ,로 split 했을 때 1과 2로 잘 분리되는지 확인하는 학습 테스트를 구현한다. (O)
+    -"1"을 ,로 split 했을 때 1만을 포함하는 배열이 반환되는지에 대한 학습 테스트를 구현한다. (O)
+    [힌트]
+    -배열로 반환하는 값의 경우 assertj의 contains()를 활용해 반환 값이 맞는지 검증한다.
+    -배열로 반환하는 값의 경우 assertj의 containsExactly()를 활용해 반환 값이 맞는지 검증한다.
+    */
+    @Test
+    @DisplayName("배열 요소에 1,2 모두 포함한다.")
+    void split() {
+        String[] numbers = "1,2".split(",");
+        assertThat(numbers).containsAll(Arrays.asList("1", "2"));
+        assertThat(numbers).containsExactly("1", "2");
+    }
+
+    @Test
+    @DisplayName("배열에 1만 존재한다.")
+    void split1() {
+        String[] number = "1".split(",");
+        assertThat(number).containsAll(Arrays.asList("1"));
+        assertThat(number).containsExactly("1");
+    }
+
+    /* 요구사항 2)
+    -"(1,2)" 값이 주어졌을 때 String의 substring() 메소드를 활용해 ()을 제거하고 "1,2"를 반환하도록 구현한다.
+    */
+    @Test
+    @DisplayName("괄호를 제거하고 숫자만 반환한다.")
+    void substring() {
+        String number = "(1,2)".substring(1,4);
+        assertThat(number).isEqualTo("1,2");
+    }
+
+    /* 요구사항 3)
+    -"abc" 값이 주어졌을 때 String의 charAt() 메소드를 활용해 특정 위치의 문자를 가져오는 학습 테스트를 구현한다.
+    -String의 charAt() 메소드를 활용해 특정 위치의 문자를 가져올 때 위치 값을 벗어나면 StringIndexOutOfBoundsException이 발생하는 부분에 대한 학습 테스트를 구현한다.
+    */
+    @Test
+    @DisplayName("b를 가져온다.")
+    void charAtB() {
+        String b = String.valueOf("abc".charAt(1));
+        assertThat(b).isEqualTo("b");
+    }
+
+    @Test
+    @DisplayName("charAt 범위를 넘어서서 특정 문자를 가져오지 못한다.")
+    void charAtException2() {
+        String string = "abc";
+        assertThatExceptionOfType(StringIndexOutOfBoundsException.class)
+                .isThrownBy(() -> {
+                    string.charAt(2);
+                    throw new StringIndexOutOfBoundsException("Index 2 out of bounds for length 3");
+                });
+
+    }
 }

src/test/java/study/calculator/CalculatorTest.java

@@ -0,0 +1,36 @@
+package study.calculator;
+
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowable;
+
+public class CalculatorTest {
+    private Calculator calculator;
+    private Expression expression;
+
+    @ParameterizedTest
+    @DisplayName("입력받은 문자열을 연산한다.")
+    @ValueSource(strings = "1 + 2 * 3 / 2 * 14")
+    void calculate(String input) {
+        expression = new Expression(input);
+        Double result = calculator.calculate(expression.splitByBlank());
+        assertThat(result).isEqualTo(4.5);
+    }
+
+    @ParameterizedTest
+    @DisplayName("0으로 나눌 수 없다.")
+    @ValueSource(strings = "1 + 2 * 3 / 0")
+    void divisionByZero(String input) {
+        Throwable thrown = catchThrowable(() -> {
+            expression = new Expression(input);
+            calculator.calculate(expression.splitByBlank());
+        });
+        assertThat(thrown)
+                .isInstanceOf(ArithmeticException.class)
+                .hasMessageContaining("/ by zero");
+    }
+}