[보민] 문자열 덧셈 계산기

build.gradle

@@ -6,16 +6,19 @@ group 'com.ccstudy'
 version '1.0-SNAPSHOT'
 
 sourceCompatibility = 1.8
+compileJava.options.encoding = 'UTF-8'
 
 repositories {
     mavenCentral()
 }
 
 dependencies {
+    compile('org.junit.jupiter:junit-jupiter:5.6.0')
     testCompile('org.junit.jupiter:junit-jupiter:5.6.0')
     testCompile group: 'org.assertj', name: 'assertj-core', version: '3.15.0'
+    testCompile "org.mockito:mockito-core:1.+"
 }
 
 test{
     useJUnitPlatform()
-}
+}

src/main/java/calculator/Calculator.java

@@ -0,0 +1,11 @@
+package calculator;
+
+public class Calculator {
+	public static int addValues(String[] tokens, Parser parser) {
+		int result = 0;
+		for (int i = 0; i < tokens.length; i++) {
+			result += parser.stringToInteger(tokens[i]);
+		}
+		return result;
+	}
+}

src/main/java/calculator/GetInput.java

@@ -0,0 +1,11 @@
+package calculator;
+
+import java.util.Scanner;
+
+public class GetInput {
+	public static String getInput() {
+		System.out.println("input : ");
+		Scanner scanner = new Scanner(System.in);
+		return scanner.nextLine();
+	}
+}

src/main/java/calculator/InputChecking.java

@@ -0,0 +1,18 @@
+package calculator;
+
+public class InputChecking {
+
+	public static boolean checkIsTheInputBlank(String value) {
+		if (value == null || value.isEmpty()) {
+			System.out.println("0");
+			throw new NullPointerException();
+		}
+		return true;
+	}
+
+	public static void checkSinglularityAndPrintResult(String inputValue, Parser singleParser) {
+		if (inputValue.length() == 1) {
+			System.out.println("result : " + singleParser.parseSingleValue(inputValue));
+		}
+	}
+}

src/main/java/calculator/Parser.java

@@ -0,0 +1,33 @@
+package calculator;
+
+public class Parser {
+	public int stringToInteger(String stringToInt) {
+		int toInt = 0;
+		try {
+			toInt = Integer.parseInt(stringToInt);
+			checkTheValueIsPositive(toInt);
+			return toInt;
+		} catch (NumberFormatException numberFormatException) {
+			System.out.println("Error Message : " + numberFormatException.getMessage());
+		}
+		return toInt;
+	}
+
+	private void checkTheValueIsPositive(int number) {
+		if (number < 0) {
+			System.out.println("양수를 입력하세요");
+			throw new IllegalArgumentException();
+		}
+	}
+
+	public int parseSingleValue(String inputValue) {
+		int result = 0;
+		try {
+			result = Integer.parseInt(inputValue);
+		} catch (NumberFormatException parsingFail) {
+			System.out.println("숫자를 입력하세요");
+			System.exit(0);
+		}
+		return result;
+	}
+}

src/main/java/calculator/Splitter.java

@@ -0,0 +1,30 @@
+package calculator;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class Splitter {
+	public static final String DEFAULT_DELIMITER = "[,:]";
+	public static final String CUSTOM_DELIMITER_REGEX = "//(.)\n(.*)";
+	public static final int DELIMETER_GROUP = 1;
+	public static final int TOKEN_GROUP = 2;
+
+	private Pattern pattern = Pattern.compile(CUSTOM_DELIMITER_REGEX);
+
+	public String[] getTokens(String text) {
+		if (text.contains(DEFAULT_DELIMITER)) {
+			return splitByDefaultDelimiter(text);
+		}
+		return splitByCustomDelimeter(text);
+	}
+
+	private String[] splitByDefaultDelimiter(String text) {
+		return text.split(DEFAULT_DELIMITER);
+	}
+
+	private String[] splitByCustomDelimeter(String text) {
+		Matcher matcher = pattern.matcher(text);
+		String customDelimeter = matcher.group(DELIMETER_GROUP);
+		return matcher.group(TOKEN_GROUP).split(customDelimeter);
+	}
+}

src/main/java/calculator/StringAddingCalculatorApplication.java

@@ -0,0 +1,17 @@
+package calculator;
+
+public class StringAddingCalculatorApplication {
+	public static void main(String[] args) {
+		String inputValue = GetInput.getInput();
+
+		InputChecking.checkIsTheInputBlank(inputValue);
+
+		Parser parser = new Parser();
+		InputChecking.checkSinglularityAndPrintResult(inputValue, parser);
+
+		Splitter splitter = new Splitter();
+		String[] tokens = splitter.getTokens(inputValue);
+
+		System.out.println("result : " + Calculator.addValues(tokens, parser));
+	}
+}

src/test/java/calculator/InputCheckingTest.java

@@ -0,0 +1,28 @@
+package calculator;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class InputCheckingTest {
+
+
+	@DisplayName("인자의 값이 빈칸 또는 null 인지 점검한다.")
+	@Test
+	void shouldCheckIsTheInputBlankTest() {
+		String isBlank = "";
+		String isNull = null;
+		assertThat(InputChecking.checkIsTheInputBlank(isBlank)).isTrue();
+		assertThat(InputChecking.checkIsTheInputBlank(isNull)).isTrue();
+	}
+
+	@DisplayName("인자의 값이 한 글자일 때, 글자수를 올바르게 판단하는 지 점검")
+	@ParameterizedTest
+	@ValueSource(strings = {"1", "2", "3", "23", "12"})
+	void shouldCheckSinglularityTest(String values) {
+		assertThat(InputChecking.checkSinglularityAndPrintResult(values)).isTrue();
+	}
+}

src/test/java/calculator/ParserTest.java

@@ -0,0 +1,47 @@
+package calculator;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class ParserTest {
+	Parser parser = new Parser();
+
+	@DisplayName("String을 Integer로 올바르게 파싱하는 지 점검")
+	@Test
+	void stringToInteger() {
+		String stringToInt = "3";
+		assertThat(parser.stringToInteger(stringToInt)).isEqualTo(3);
+	}
+
+	@DisplayName("인자가 문자일 때, 터지는 exception 점검.")
+	@Test
+	void shouldThrowException() {
+		String invalidValue = "j";
+		assertThat(parser.stringToInteger(invalidValue)).isEqualTo(new NumberFormatException());
+	}
+
+	@DisplayName("양수인지 점검")
+	@Test
+	void shouldCheckPositiveValueTest() {
+		String negativeInt = "-1";
+		assertThatThrownBy(() -> new Parser().stringToInteger(negativeInt))
+				.isInstanceOf(IllegalArgumentException.class);
+	}
+
+	@DisplayName("문자 하나를 입력했을 때, 제대로 파싱되는 지")
+	@Test
+	void singleValueTest() {
+		String singleValue = "1";
+		assertThat(parser.parseSingleValue(singleValue)).isEqualTo(1);
+	}
+
+	@DisplayName("숫자가 아닌 값을 입력했을 때, 오류")
+	@Test
+	void invalidSingleValueTest() {
+		String invalidSingleValue = "j";
+		assertThat(parser.parseSingleValue(invalidSingleValue)).isEqualTo(new NumberFormatException());
+	}
+}

src/test/java/calculator/SplitterTest.java

@@ -0,0 +1,26 @@
+package calculator;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SplitterTest {
+	Splitter splitter = new Splitter();
+
+	@DisplayName("Custom delimeter test")
+	@Test
+	void customDelimeterTest() {
+		String inputText = "//;\n1;2;3";
+		String[] inspectTokens = {"1", "2", "3"};
+		assertThat(splitter.getTokens(inputText)).isEqualTo(inspectTokens);
+	}
+
+	@DisplayName("Default delimeter test")
+	@Test
+	void defaultDelimeterTest() {
+		String inputText = "1,2:3";
+		String[] inspectTokens = {"1", "2", "3"};
+		assertThat(splitter.getTokens(inputText)).isEqualTo(inspectTokens);
+	}
+}