From dc2e002d5313f4a75862dce3e6c9c86f354795fe Mon Sep 17 00:00:00 2001 From: viiviii Date: Fri, 6 May 2022 13:20:53 +0900 Subject: [PATCH 1/4] =?UTF-8?q?=E2=9C=A8=2014.=20=EC=A0=90=EC=A7=84?= =?UTF-8?q?=EC=A0=81=EC=9D=B8=20=EA=B0=9C=EC=84=A0=20-=20Only=20boolean=20?= =?UTF-8?q?(#2)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat: Boolean 인수만 지원하던 초기 버전 / 목록 14-9 * test: Boolean 인수만 지원하던 초기 버전 테스트 추가 * :truck: Args 클래스 패키지 안으로 이동 --- src/main/java/chapter14/Application.java | 17 +++ src/main/java/chapter14/args/Args.java | 121 ++++++++++++++++++ src/test/java/chapter14/ApplicationTest.java | 37 ++++++ src/test/java/chapter14/MainMethodTest.java | 39 ++++++ src/test/java/chapter14/args/ArgsTest.java | 123 +++++++++++++++++++ 5 files changed, 337 insertions(+) create mode 100644 src/main/java/chapter14/Application.java create mode 100644 src/main/java/chapter14/args/Args.java create mode 100644 src/test/java/chapter14/ApplicationTest.java create mode 100644 src/test/java/chapter14/MainMethodTest.java create mode 100644 src/test/java/chapter14/args/ArgsTest.java diff --git a/src/main/java/chapter14/Application.java b/src/main/java/chapter14/Application.java new file mode 100644 index 0000000..e5bf584 --- /dev/null +++ b/src/main/java/chapter14/Application.java @@ -0,0 +1,17 @@ +package chapter14; + +import chapter14.args.Args; + +class Application { + + public static void main(String[] args) { + Args arg = new Args("l", args); + boolean logging = arg.getBoolean('l'); + executeApplication(logging); + } + + // stub + private static void executeApplication(boolean logging) { + System.out.printf("logging: %b\n", logging); + } +} diff --git a/src/main/java/chapter14/args/Args.java b/src/main/java/chapter14/args/Args.java new file mode 100644 index 0000000..6f75c8e --- /dev/null +++ b/src/main/java/chapter14/args/Args.java @@ -0,0 +1,121 @@ +package chapter14.args; + +import java.util.HashMap; +import java.util.Map; +import java.util.Set; +import java.util.TreeSet; + +public class Args { + private String scheme; + private String[] args; + private boolean valid; + private Set unexpectedArguments = new TreeSet<>(); + private Map booleanArgs = new HashMap<>(); + private int numberOfArguments = 0; + + public Args(String schema, String[] args) { + this.scheme = schema; + this.args = args; + valid = parse(); + } + + public boolean isValid() { + return valid; + } + + private boolean parse() { + if (scheme.length() == 0 && args.length == 0) + return true; + parseSchema(); + parseArguments(); + return unexpectedArguments.size() == 0; + } + + private boolean parseSchema() { + for (String element : scheme.split(",")) { + parseSchemaElement(element); + } + return true; + } + + private void parseSchemaElement(String element) { + if (element.length() == 1) { + parseBooleanSchemeElement(element); + } + } + + private void parseBooleanSchemeElement(String element) { + char c = element.charAt(0); + if (Character.isLetter(c)) { + booleanArgs.put(c, false); + } + } + + private boolean parseArguments() { + for (String arg : args) { + parseArgument(arg); + } + return true; + } + + private void parseArgument(String arg) { + if (arg.startsWith("-")) + parseElements(arg); + } + + private void parseElements(String arg) { + for (int i = 1; i < arg.length(); i++) { + parseElement(arg.charAt(i)); + } + } + + private void parseElement(char argChar) { + if (isBoolean(argChar)) { + numberOfArguments++; + setBooleanArg(argChar, true); + } else { + unexpectedArguments.add(argChar); + } + } + + private void setBooleanArg(char argChar, boolean value) { + booleanArgs.put(argChar, value); + } + + private boolean isBoolean(char argChar) { + return booleanArgs.containsKey(argChar); + } + + public int cardinality() { + return numberOfArguments; + } + + public String usage() { + if (scheme.length() > 0) + return "-[" + scheme + "]"; + else + return ""; + } + + public String errorMessage() { + if (unexpectedArguments.size() > 0) { + return unexpectedArgumentMessage(); + } else { + return ""; + } + } + + private String unexpectedArgumentMessage() { + StringBuffer message = new StringBuffer("Argument(s) -"); + for (char c : unexpectedArguments) { + message.append(c); + } + message.append(" unexpected."); + + return message.toString(); + } + + public boolean getBoolean(char arg) { + return booleanArgs.get(arg); + } +} diff --git a/src/test/java/chapter14/ApplicationTest.java b/src/test/java/chapter14/ApplicationTest.java new file mode 100644 index 0000000..101aeb8 --- /dev/null +++ b/src/test/java/chapter14/ApplicationTest.java @@ -0,0 +1,37 @@ +package chapter14; + +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +class ApplicationTest extends MainMethodTest { + + @Test + void validBooleanArgs() { + //given + String arg = "-l"; + + //when + runMain(arg); + + //then + assertThat(output()).contains("logging: true"); + } + + @Test + void invalidBooleanArgs() { + //given + String notStartWithHyphen = "l"; + + //when + runMain(notStartWithHyphen); + + //then + assertThat(output()).contains("logging: false"); + } + + @Override + protected void runMain(String... args) { + Application.main(args); + } +} \ No newline at end of file diff --git a/src/test/java/chapter14/MainMethodTest.java b/src/test/java/chapter14/MainMethodTest.java new file mode 100644 index 0000000..e0bf861 --- /dev/null +++ b/src/test/java/chapter14/MainMethodTest.java @@ -0,0 +1,39 @@ +package chapter14; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; + +import java.io.ByteArrayOutputStream; +import java.io.OutputStream; +import java.io.PrintStream; + +abstract class MainMethodTest { + private final PrintStream standardOut = System.out; + private OutputStream captor; + + @BeforeEach + protected final void init() { + setSystemOutToMyPrintStreamForCaptor(); + } + + private void setSystemOutToMyPrintStreamForCaptor() { + captor = new ByteArrayOutputStream(); + System.setOut(new PrintStream(captor)); + } + + @AfterEach + protected final void printOutput() { + setSystemOutToStandard(); + System.out.println(output()); + } + + private void setSystemOutToStandard() { + System.setOut(standardOut); + } + + protected final String output() { + return captor.toString().trim(); + } + + protected abstract void runMain(String... args); +} diff --git a/src/test/java/chapter14/args/ArgsTest.java b/src/test/java/chapter14/args/ArgsTest.java new file mode 100644 index 0000000..f1a2e4c --- /dev/null +++ b/src/test/java/chapter14/args/ArgsTest.java @@ -0,0 +1,123 @@ +package chapter14.args; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +class ArgsTest { + + @DisplayName("scheme와 arguments가 없는 경우") + @Test + void noSchemaAndArguments() { + //given + String schema = ""; + String[] arguments = new String[0]; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isZero(); + } + + @DisplayName("scheme가 없고 argument가 1개 있는 경우") + @Test + void noSchemaButWithOneArgument() { + //given + String schema = ""; + String[] arguments = new String[]{"-x"}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isFalse(); + assertThat(args.cardinality()).isZero(); + assertThat(args.errorMessage()).isEqualTo("Argument(s) -x unexpected."); + } + + @DisplayName("scheme가 없고 argument가 여러 개 있는 경우") + @Test + void noSchemaButWithMultipleArguments() { + //given + String schema = ""; + String[] arguments = new String[]{"-x", "-y"}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isFalse(); + assertThat(args.cardinality()).isZero(); + assertThat(args.errorMessage()).isEqualTo("Argument(s) -xy unexpected."); + } + + @DisplayName("boolean 값이 없는 경우") + @Test + void simpleBooleanNotPresent() { + //given + String schema = "x"; + String[] arguments = new String[]{}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isZero(); + assertThat(args.getBoolean('x')).isFalse(); + } + + @DisplayName("boolean 값이 있는 경우") + @Test + void simpleBooleanPresent() { + //given + String schema = "x"; + String[] arguments = new String[]{"-x"}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isOne(); + assertThat(args.getBoolean('x')).isTrue(); + } + + @DisplayName("boolean 값이 여러 개 있는 경우") + @Test + void simpleBooleanMultiplePresent() { + //given + String schema = "x,y"; + String[] arguments = new String[]{"-x", "-y"}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isEqualTo(2); + assertThat(args.getBoolean('x')).isTrue(); + assertThat(args.getBoolean('y')).isTrue(); + } + + @DisplayName("boolean 값이 여러 개 중 하나만 있는 경우") + @Test + void simpleBooleanOnlyOnePresent() { + //given + String schema = "x,y,z"; + String[] arguments = new String[]{"-z"}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isOne(); + assertThat(args.getBoolean('x')).isFalse(); + assertThat(args.getBoolean('y')).isFalse(); + assertThat(args.getBoolean('z')).isTrue(); + } +} \ No newline at end of file From 2bf8e175489b8fa81faf3751515af3fdd6b6a94d Mon Sep 17 00:00:00 2001 From: viiviii Date: Fri, 6 May 2022 15:54:59 +0900 Subject: [PATCH 2/4] =?UTF-8?q?=E2=9C=A8=2014.=20=EC=A0=90=EC=A7=84?= =?UTF-8?q?=EC=A0=81=EC=9D=B8=20=EA=B0=9C=EC=84=A0=20-=20Add=20String=20(#?= =?UTF-8?q?3)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat: String 인수 유형 추가 버전 / 목록 14-10 * test: String 인수 유형 추가 버전 테스트 추가 * fix: schema 오타 수정 --- src/main/java/chapter14/Application.java | 17 +- src/main/java/chapter14/args/Args.java | 155 ++++++++++++++----- src/test/java/chapter14/ApplicationTest.java | 40 ++++- src/test/java/chapter14/args/ArgsTest.java | 128 +++++++++++++-- 4 files changed, 273 insertions(+), 67 deletions(-) diff --git a/src/main/java/chapter14/Application.java b/src/main/java/chapter14/Application.java index e5bf584..e01e518 100644 --- a/src/main/java/chapter14/Application.java +++ b/src/main/java/chapter14/Application.java @@ -2,16 +2,23 @@ import chapter14.args.Args; +import java.text.ParseException; + class Application { public static void main(String[] args) { - Args arg = new Args("l", args); - boolean logging = arg.getBoolean('l'); - executeApplication(logging); + try { + Args arg = new Args("l,d*", args); + boolean logging = arg.getBoolean('l'); + String directory = arg.getString('d'); + executeApplication(logging, directory); + } catch (ParseException e) { + System.out.printf("Parse error: %s\n", e.getMessage()); + } } // stub - private static void executeApplication(boolean logging) { - System.out.printf("logging: %b\n", logging); + private static void executeApplication(boolean logging, String directory) { + System.out.printf("logging: %b, directory: %s\n", logging, directory); } } diff --git a/src/main/java/chapter14/args/Args.java b/src/main/java/chapter14/args/Args.java index 6f75c8e..add22cc 100644 --- a/src/main/java/chapter14/args/Args.java +++ b/src/main/java/chapter14/args/Args.java @@ -1,58 +1,85 @@ package chapter14.args; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; -import java.util.TreeSet; +import java.text.ParseException; +import java.util.*; public class Args { - private String scheme; + private String schema; private String[] args; - private boolean valid; + private boolean valid = true; private Set unexpectedArguments = new TreeSet<>(); private Map booleanArgs = new HashMap<>(); - private int numberOfArguments = 0; + private Map stringArgs = new HashMap<>(); + private Set argsFound = new HashSet<>(); + private int currentArgument; + private char errorArgument = '\0'; - public Args(String schema, String[] args) { - this.scheme = schema; - this.args = args; - valid = parse(); + enum ErrorCode { + OK, MISSING_STRING } - public boolean isValid() { - return valid; + private ErrorCode errorCode = ErrorCode.OK; + + public Args(String schema, String[] args) throws ParseException { + this.schema = schema; + this.args = args; + valid = parse(); } - private boolean parse() { - if (scheme.length() == 0 && args.length == 0) + private boolean parse() throws ParseException { + if (schema.length() == 0 && args.length == 0) return true; parseSchema(); parseArguments(); - return unexpectedArguments.size() == 0; + return valid; } - private boolean parseSchema() { - for (String element : scheme.split(",")) { - parseSchemaElement(element); + private boolean parseSchema() throws ParseException { + for (String element : schema.split(",")) { + if (element.length() > 0) { + String trimmedElement = element.trim(); + parseSchemaElement(trimmedElement); + } } return true; } - private void parseSchemaElement(String element) { - if (element.length() == 1) { - parseBooleanSchemeElement(element); - } + private void parseSchemaElement(String element) throws ParseException { + char elementId = element.charAt(0); + String elementTail = element.substring(1); + validateSchemaElementId(elementId); + if (isBooleanSchemaElement(elementTail)) + parseBooleanSchemaElement(elementId); + else if (isStringSchemaElement(elementTail)) + parseStringSchemaElement(elementId); } - private void parseBooleanSchemeElement(String element) { - char c = element.charAt(0); - if (Character.isLetter(c)) { - booleanArgs.put(c, false); + private void validateSchemaElementId(char elementId) throws ParseException { + if (!Character.isLetter(elementId)) { + throw new ParseException( + "Bad character: " + elementId + " in Args format: " + schema, 0); } } + private void parseStringSchemaElement(char elementId) { + stringArgs.put(elementId, ""); + } + + private boolean isStringSchemaElement(String elementTail) { + return elementTail.equals("*"); + } + + private boolean isBooleanSchemaElement(String elementTail) { + return elementTail.length() == 0; + } + + private void parseBooleanSchemaElement(char elementId) { + booleanArgs.put(elementId, false); + } + private boolean parseArguments() { - for (String arg : args) { + for (currentArgument = 0; currentArgument < args.length; currentArgument++) { + String arg = args[currentArgument]; parseArgument(arg); } return true; @@ -70,14 +97,41 @@ private void parseElements(String arg) { } private void parseElement(char argChar) { - if (isBoolean(argChar)) { - numberOfArguments++; - setBooleanArg(argChar, true); - } else { + if (setArgument(argChar)) + argsFound.add(argChar); + else { unexpectedArguments.add(argChar); + valid = false; } } + private boolean setArgument(char argChar) { + boolean set = true; + if (isBoolean(argChar)) + setBooleanArg(argChar, true); + else if (isString(argChar)) + setStringArg(argChar, ""); + else + set = false; + + return set; + } + + private void setStringArg(char argChar, String s) { + currentArgument++; + try { + stringArgs.put(argChar, args[currentArgument]); + } catch (ArrayIndexOutOfBoundsException e) { + valid = false; + errorArgument = argChar; + errorCode = ErrorCode.MISSING_STRING; + } + } + + private boolean isString(char argChar) { + return stringArgs.containsKey(argChar); + } + private void setBooleanArg(char argChar, boolean value) { booleanArgs.put(argChar, value); } @@ -87,20 +141,27 @@ private boolean isBoolean(char argChar) { } public int cardinality() { - return numberOfArguments; + return argsFound.size(); } public String usage() { - if (scheme.length() > 0) - return "-[" + scheme + "]"; + if (schema.length() > 0) + return "-[" + schema + "]"; else return ""; } - public String errorMessage() { + public String errorMessage() throws Exception { if (unexpectedArguments.size() > 0) { return unexpectedArgumentMessage(); } else { + switch (errorCode) { + case MISSING_STRING: + return String.format("Could not find string parameter for -%c.", + errorArgument); + case OK: + throw new Exception("TILT: Should not get here."); + } return ""; } } @@ -116,6 +177,26 @@ private String unexpectedArgumentMessage() { } public boolean getBoolean(char arg) { - return booleanArgs.get(arg); + return falseIfNull(booleanArgs.get(arg)); + } + + private boolean falseIfNull(Boolean b) { + return b == null ? false : b; + } + + public String getString(char arg) { + return blankIfNull(stringArgs.get(arg)); + } + + private String blankIfNull(String s) { + return s == null ? "" : s; + } + + public boolean has(char arg) { + return argsFound.contains(arg); + } + + public boolean isValid() { + return valid; } } diff --git a/src/test/java/chapter14/ApplicationTest.java b/src/test/java/chapter14/ApplicationTest.java index 101aeb8..680ed1c 100644 --- a/src/test/java/chapter14/ApplicationTest.java +++ b/src/test/java/chapter14/ApplicationTest.java @@ -7,27 +7,51 @@ class ApplicationTest extends MainMethodTest { @Test - void validBooleanArgs() { + void booleanArguments() { //given - String arg = "-l"; + String[] args = new String[]{"-l"}; //when - runMain(arg); + runMain(args); //then - assertThat(output()).contains("logging: true"); + assertThat(output()).contains("true"); } @Test - void invalidBooleanArgs() { + void stringArguments() { //given - String notStartWithHyphen = "l"; + String[] args = new String[]{"-d", "root"}; //when - runMain(notStartWithHyphen); + runMain(args); //then - assertThat(output()).contains("logging: false"); + assertThat(output()).contains("root"); + } + + @Test + void allArgumentsPresent() { + //given + String[] args = new String[]{"-l", "-d", "user"}; + + //when + runMain(args); + + //then + assertThat(output()).isEqualTo("logging: true, directory: user"); + } + + @Test + void noArguments() { + //given + String[] args = new String[0]; + + //when + runMain(args); + + //then + assertThat(output()).isEqualTo("logging: false, directory:"); } @Override diff --git a/src/test/java/chapter14/args/ArgsTest.java b/src/test/java/chapter14/args/ArgsTest.java index f1a2e4c..d62504b 100644 --- a/src/test/java/chapter14/args/ArgsTest.java +++ b/src/test/java/chapter14/args/ArgsTest.java @@ -3,13 +3,16 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import java.text.ParseException; + import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.catchException; class ArgsTest { - @DisplayName("scheme와 arguments가 없는 경우") + @DisplayName("schema와 arguments가 없는 경우") @Test - void noSchemaAndArguments() { + void noSchemaAndArguments() throws Exception { //given String schema = ""; String[] arguments = new String[0]; @@ -22,9 +25,9 @@ void noSchemaAndArguments() { assertThat(args.cardinality()).isZero(); } - @DisplayName("scheme가 없고 argument가 1개 있는 경우") + @DisplayName("schema가 없고 argument가 1개 있는 경우") @Test - void noSchemaButWithOneArgument() { + void noSchemaButWithOneArgument() throws Exception { //given String schema = ""; String[] arguments = new String[]{"-x"}; @@ -38,9 +41,9 @@ void noSchemaButWithOneArgument() { assertThat(args.errorMessage()).isEqualTo("Argument(s) -x unexpected."); } - @DisplayName("scheme가 없고 argument가 여러 개 있는 경우") + @DisplayName("schema가 없고 argument가 여러 개 있는 경우") @Test - void noSchemaButWithMultipleArguments() { + void noSchemaButWithMultipleArguments() throws Exception { //given String schema = ""; String[] arguments = new String[]{"-x", "-y"}; @@ -56,7 +59,7 @@ void noSchemaButWithMultipleArguments() { @DisplayName("boolean 값이 없는 경우") @Test - void simpleBooleanNotPresent() { + void simpleBooleanNotPresent() throws Exception { //given String schema = "x"; String[] arguments = new String[]{}; @@ -72,7 +75,7 @@ void simpleBooleanNotPresent() { @DisplayName("boolean 값이 있는 경우") @Test - void simpleBooleanPresent() { + void simpleBooleanPresent() throws Exception { //given String schema = "x"; String[] arguments = new String[]{"-x"}; @@ -88,9 +91,9 @@ void simpleBooleanPresent() { @DisplayName("boolean 값이 여러 개 있는 경우") @Test - void simpleBooleanMultiplePresent() { + void simpleBooleanMultiplePresent() throws Exception { //given - String schema = "x,y"; + String schema = "x,y,z"; String[] arguments = new String[]{"-x", "-y"}; //when @@ -99,16 +102,37 @@ void simpleBooleanMultiplePresent() { //then assertThat(args.isValid()).isTrue(); assertThat(args.cardinality()).isEqualTo(2); + assertThat(args.has('x')).isTrue(); + assertThat(args.has('y')).isTrue(); + assertThat(args.has('z')).isFalse(); assertThat(args.getBoolean('x')).isTrue(); assertThat(args.getBoolean('y')).isTrue(); + assertThat(args.getBoolean('z')).isFalse(); } - @DisplayName("boolean 값이 여러 개 중 하나만 있는 경우") + @DisplayName("String 값이 없는 경우") @Test - void simpleBooleanOnlyOnePresent() { + void simpleStringNotPresent() throws Exception { //given - String schema = "x,y,z"; - String[] arguments = new String[]{"-z"}; + String schema = "x*"; + String[] arguments = new String[]{}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isZero(); + assertThat(args.has('x')).isFalse(); + assertThat(args.getString('x')).isEmpty(); + } + + @DisplayName("String 값이 있는 경우") + @Test + void simpleStringPresent() throws Exception { + //given + String schema = "x*"; + String[] arguments = new String[]{"-x", "param"}; //when Args args = new Args(schema, arguments); @@ -116,8 +140,78 @@ void simpleBooleanOnlyOnePresent() { //then assertThat(args.isValid()).isTrue(); assertThat(args.cardinality()).isOne(); - assertThat(args.getBoolean('x')).isFalse(); - assertThat(args.getBoolean('y')).isFalse(); - assertThat(args.getBoolean('z')).isTrue(); + assertThat(args.has('x')).isTrue(); + assertThat(args.getString('x')).isEqualTo("param"); + } + + @DisplayName("String 값이 여러 개 있는 경우") + @Test + void simpleStringMultiplePresent() throws Exception { + //given + String schema = "x*,y*,z*"; + String[] arguments = new String[]{"-x", "param1", "-y", "param2"}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isEqualTo(2); + assertThat(args.has('x')).isTrue(); + assertThat(args.has('y')).isTrue(); + assertThat(args.has('z')).isFalse(); + assertThat(args.getString('x')).isEqualTo("param1"); + assertThat(args.getString('y')).isEqualTo("param2"); + assertThat(args.getString('z')).isEmpty(); + } + + @DisplayName("String Argument 값이 없는 경우") + @Test + void missingStringArgument() throws Exception { + //given + String schema = "x*"; + String[] arguments = new String[]{"-x"}; // missing + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isFalse(); + assertThat(args.cardinality()).isOne(); + assertThat(args.has('x')).isTrue(); + assertThat(args.getString('x')).isEmpty(); + assertThat(args.errorMessage()).isEqualTo("Could not find string parameter for -x."); + } + + @DisplayName("Schema의 ElementId가 문자가 아니면 ParseException이 발생한다") + @Test + void throwParseExceptionWhenInvalidSchemaElementId() { + //given + String containsNonLetterElementId = "l,d*,#"; + String[] arguments = new String[0]; + + //when + Exception exception = catchException(() -> new Args(containsNonLetterElementId, arguments)); + + //then + assertThat(exception) + .isInstanceOf(ParseException.class) + .hasMessage("Bad character: # in Args format: l,d*,#"); + } + + @DisplayName("유효한 args에서 errorMessage를 조회할 경우 Excpetion이 발생한다") + @Test + void errorMessageThrowExceptionWhenErrorCodeIsOK() throws Exception { + //given + Args args = new Args("x", new String[]{"-x"}); + assertThat(args.isValid()).isTrue(); + + //when + Exception exception = catchException(args::errorMessage); + + //then + assertThat(exception) + .isInstanceOf(Exception.class) + .hasMessage("TILT: Should not get here."); } } \ No newline at end of file From d59d861a0d2e9b72109aefd31d333887c611be16 Mon Sep 17 00:00:00 2001 From: viiviii Date: Wed, 11 May 2022 18:32:33 +0900 Subject: [PATCH 3/4] =?UTF-8?q?=E2=9C=A8=2014.=20=EC=A0=90=EC=A7=84?= =?UTF-8?q?=EC=A0=81=EC=9D=B8=20=EA=B0=9C=EC=84=A0=20-=20Add=20Integer=20(?= =?UTF-8?q?&before=20refactoring=20ver)=20(#4)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat: int 유형 추가 * test: int 유형 테스트 추가 * test: 기존 테스트를 책에 나온 테스트와 메서드명 및 순서 맞춤 * feat: 유효하지 않은 Schema element를 예외 처리 * refactor: 책과 순서 맞춤 및 메서드명 변경 등 작은 리팩토링 * refactor: UNEXPECTED_ARGUMENT errorCode 추가하여 리팩토링 * feat: ArgsException 추가 * refactor: errorArgument -> errorArgumentId로 변수명 변경 --- src/main/java/chapter14/Application.java | 9 +- src/main/java/chapter14/args/Args.java | 139 +++++++++++++----- src/test/java/chapter14/ApplicationTest.java | 18 ++- src/test/java/chapter14/args/ArgsTest.java | 146 ++++++++++++++++--- 4 files changed, 246 insertions(+), 66 deletions(-) diff --git a/src/main/java/chapter14/Application.java b/src/main/java/chapter14/Application.java index e01e518..ca77f84 100644 --- a/src/main/java/chapter14/Application.java +++ b/src/main/java/chapter14/Application.java @@ -8,17 +8,18 @@ class Application { public static void main(String[] args) { try { - Args arg = new Args("l,d*", args); + Args arg = new Args("l,p#,d*", args); boolean logging = arg.getBoolean('l'); + int port = arg.getInt('p'); String directory = arg.getString('d'); - executeApplication(logging, directory); + executeApplication(logging, port, directory); } catch (ParseException e) { System.out.printf("Parse error: %s\n", e.getMessage()); } } // stub - private static void executeApplication(boolean logging, String directory) { - System.out.printf("logging: %b, directory: %s\n", logging, directory); + private static void executeApplication(boolean logging, int port, String directory) { + System.out.printf("logging: %b, port: %d, directory: %s\n", logging, port, directory); } } diff --git a/src/main/java/chapter14/args/Args.java b/src/main/java/chapter14/args/Args.java index add22cc..1f4429a 100644 --- a/src/main/java/chapter14/args/Args.java +++ b/src/main/java/chapter14/args/Args.java @@ -10,16 +10,17 @@ public class Args { private Set unexpectedArguments = new TreeSet<>(); private Map booleanArgs = new HashMap<>(); private Map stringArgs = new HashMap<>(); + private Map intArgs = new HashMap<>(); private Set argsFound = new HashSet<>(); private int currentArgument; - private char errorArgument = '\0'; + private char errorArgumentId = '\0'; + private String errorParameter = "TILT"; + private ErrorCode errorCode = ErrorCode.OK; enum ErrorCode { - OK, MISSING_STRING + OK, MISSING_STRING, MISSING_INTEGER, INVALID_INTEGER, UNEXPECTED_ARGUMENT } - private ErrorCode errorCode = ErrorCode.OK; - public Args(String schema, String[] args) throws ParseException { this.schema = schema; this.args = args; @@ -30,7 +31,10 @@ private boolean parse() throws ParseException { if (schema.length() == 0 && args.length == 0) return true; parseSchema(); - parseArguments(); + try { + parseArguments(); + } catch (ArgsException e) { + } return valid; } @@ -52,6 +56,13 @@ private void parseSchemaElement(String element) throws ParseException { parseBooleanSchemaElement(elementId); else if (isStringSchemaElement(elementTail)) parseStringSchemaElement(elementId); + else if (isIntegerSchemaElement(elementTail)) + parseIntegerSchemaElement(elementId); + else { + throw new ParseException( + String.format("Argument: %c has invalid format: %s.", + elementId, elementTail), 0); + } } private void validateSchemaElementId(char elementId) throws ParseException { @@ -61,6 +72,14 @@ private void validateSchemaElementId(char elementId) throws ParseException { } } + private void parseBooleanSchemaElement(char elementId) { + booleanArgs.put(elementId, false); + } + + private void parseIntegerSchemaElement(char elementId) { + intArgs.put(elementId, 0); + } + private void parseStringSchemaElement(char elementId) { stringArgs.put(elementId, ""); } @@ -73,11 +92,11 @@ private boolean isBooleanSchemaElement(String elementTail) { return elementTail.length() == 0; } - private void parseBooleanSchemaElement(char elementId) { - booleanArgs.put(elementId, false); + private boolean isIntegerSchemaElement(String elementTail) { + return elementTail.equals("#"); } - private boolean parseArguments() { + private boolean parseArguments() throws ArgsException { for (currentArgument = 0; currentArgument < args.length; currentArgument++) { String arg = args[currentArgument]; parseArgument(arg); @@ -85,50 +104,76 @@ private boolean parseArguments() { return true; } - private void parseArgument(String arg) { + private void parseArgument(String arg) throws ArgsException { if (arg.startsWith("-")) parseElements(arg); } - private void parseElements(String arg) { + private void parseElements(String arg) throws ArgsException { for (int i = 1; i < arg.length(); i++) { parseElement(arg.charAt(i)); } } - private void parseElement(char argChar) { + private void parseElement(char argChar) throws ArgsException { if (setArgument(argChar)) argsFound.add(argChar); else { unexpectedArguments.add(argChar); + errorCode = ErrorCode.UNEXPECTED_ARGUMENT; valid = false; } } - private boolean setArgument(char argChar) { - boolean set = true; - if (isBoolean(argChar)) + private boolean setArgument(char argChar) throws ArgsException { + if (isBooleanArg(argChar)) setBooleanArg(argChar, true); - else if (isString(argChar)) - setStringArg(argChar, ""); + else if (isStringArg(argChar)) + setStringArg(argChar); + else if (isIntArg(argChar)) + setIntArg(argChar); else - set = false; + return false; + + return true; + } + + private boolean isIntArg(char argChar) { + return intArgs.containsKey(argChar); + } - return set; + private void setIntArg(char argChar) throws ArgsException { + currentArgument++; + String parameter = null; + try { + parameter = args[currentArgument]; + intArgs.put(argChar, new Integer(parameter)); + } catch (ArrayIndexOutOfBoundsException e) { + valid = false; + errorArgumentId = argChar; + errorCode = ErrorCode.MISSING_INTEGER; + throw new ArgsException(); + } catch (NumberFormatException e) { + valid = false; + errorArgumentId = argChar; + errorParameter = parameter; + errorCode = ErrorCode.INVALID_INTEGER; + throw new ArgsException(); + } } - private void setStringArg(char argChar, String s) { + private void setStringArg(char argChar) { currentArgument++; try { stringArgs.put(argChar, args[currentArgument]); } catch (ArrayIndexOutOfBoundsException e) { valid = false; - errorArgument = argChar; + errorArgumentId = argChar; errorCode = ErrorCode.MISSING_STRING; } } - private boolean isString(char argChar) { + private boolean isStringArg(char argChar) { return stringArgs.containsKey(argChar); } @@ -136,7 +181,7 @@ private void setBooleanArg(char argChar, boolean value) { booleanArgs.put(argChar, value); } - private boolean isBoolean(char argChar) { + private boolean isBooleanArg(char argChar) { return booleanArgs.containsKey(argChar); } @@ -152,18 +197,23 @@ public String usage() { } public String errorMessage() throws Exception { - if (unexpectedArguments.size() > 0) { - return unexpectedArgumentMessage(); - } else { - switch (errorCode) { - case MISSING_STRING: - return String.format("Could not find string parameter for -%c.", - errorArgument); - case OK: - throw new Exception("TILT: Should not get here."); - } - return ""; + switch (errorCode) { + case OK: + throw new Exception("TILT: Should not get here."); + case UNEXPECTED_ARGUMENT: + return unexpectedArgumentMessage(); + case MISSING_STRING: + return String.format("Could not find string parameter for -%c.", + errorArgumentId); + case INVALID_INTEGER: + return String.format("Argument -%c expects an integer but was '%s'.", + errorArgumentId, errorParameter); + case MISSING_INTEGER: + return String.format("Could not find integer parameter for -%c.", + errorArgumentId); } + return ""; + } private String unexpectedArgumentMessage() { @@ -176,22 +226,30 @@ private String unexpectedArgumentMessage() { return message.toString(); } - public boolean getBoolean(char arg) { - return falseIfNull(booleanArgs.get(arg)); - } - private boolean falseIfNull(Boolean b) { return b == null ? false : b; } - public String getString(char arg) { - return blankIfNull(stringArgs.get(arg)); + private int zeroIfNull(Integer i) { + return i == null ? 0 : i; } private String blankIfNull(String s) { return s == null ? "" : s; } + public String getString(char arg) { + return blankIfNull(stringArgs.get(arg)); + } + + public int getInt(char arg) { + return zeroIfNull(intArgs.get(arg)); + } + + public boolean getBoolean(char arg) { + return falseIfNull(booleanArgs.get(arg)); + } + public boolean has(char arg) { return argsFound.contains(arg); } @@ -199,4 +257,7 @@ public boolean has(char arg) { public boolean isValid() { return valid; } + + private class ArgsException extends Exception { + } } diff --git a/src/test/java/chapter14/ApplicationTest.java b/src/test/java/chapter14/ApplicationTest.java index 680ed1c..c000de9 100644 --- a/src/test/java/chapter14/ApplicationTest.java +++ b/src/test/java/chapter14/ApplicationTest.java @@ -30,16 +30,28 @@ void stringArguments() { assertThat(output()).contains("root"); } + @Test + void integerArguments() { + //given + String[] args = new String[]{"-p", "42"}; + + //when + runMain(args); + + //then + assertThat(output()).contains("42"); + } + @Test void allArgumentsPresent() { //given - String[] args = new String[]{"-l", "-d", "user"}; + String[] args = new String[]{"-l", "-p", "8080", "-d", "user"}; //when runMain(args); //then - assertThat(output()).isEqualTo("logging: true, directory: user"); + assertThat(output()).isEqualTo("logging: true, port: 8080, directory: user"); } @Test @@ -51,7 +63,7 @@ void noArguments() { runMain(args); //then - assertThat(output()).isEqualTo("logging: false, directory:"); + assertThat(output()).isEqualTo("logging: false, port: 0, directory:"); } @Override diff --git a/src/test/java/chapter14/args/ArgsTest.java b/src/test/java/chapter14/args/ArgsTest.java index d62504b..7cc50f5 100644 --- a/src/test/java/chapter14/args/ArgsTest.java +++ b/src/test/java/chapter14/args/ArgsTest.java @@ -57,20 +57,36 @@ void noSchemaButWithMultipleArguments() throws Exception { assertThat(args.errorMessage()).isEqualTo("Argument(s) -xy unexpected."); } - @DisplayName("boolean 값이 없는 경우") + @DisplayName("schema가 문자가 아닌 경우") @Test - void simpleBooleanNotPresent() throws Exception { + void nonLetterSchema() { //given - String schema = "x"; + String nonLetterSchemaElementId = "*"; String[] arguments = new String[]{}; //when - Args args = new Args(schema, arguments); + Exception exception = catchException(() -> new Args(nonLetterSchemaElementId, arguments)); //then - assertThat(args.isValid()).isTrue(); - assertThat(args.cardinality()).isZero(); - assertThat(args.getBoolean('x')).isFalse(); + assertThat(exception) + .isInstanceOf(ParseException.class) + .hasMessage("Bad character: * in Args format: *"); + } + + @DisplayName("schema format이 유효하지 않은 경우") + @Test + void invalidArgumentFormat() { + //given + String invalidSchemeFormat = "f~"; + String[] arguments = new String[]{}; + + //when + Exception exception = catchException(() -> new Args(invalidSchemeFormat, arguments)); + + //then + assertThat(exception) + .isInstanceOf(ParseException.class) + .hasMessage("Argument: f has invalid format: ~."); } @DisplayName("boolean 값이 있는 경우") @@ -110,11 +126,11 @@ void simpleBooleanMultiplePresent() throws Exception { assertThat(args.getBoolean('z')).isFalse(); } - @DisplayName("String 값이 없는 경우") + @DisplayName("boolean 값이 없는 경우") @Test - void simpleStringNotPresent() throws Exception { + void simpleBooleanNotPresent() throws Exception { //given - String schema = "x*"; + String schema = "x"; String[] arguments = new String[]{}; //when @@ -123,8 +139,7 @@ void simpleStringNotPresent() throws Exception { //then assertThat(args.isValid()).isTrue(); assertThat(args.cardinality()).isZero(); - assertThat(args.has('x')).isFalse(); - assertThat(args.getString('x')).isEmpty(); + assertThat(args.getBoolean('x')).isFalse(); } @DisplayName("String 값이 있는 경우") @@ -165,6 +180,23 @@ void simpleStringMultiplePresent() throws Exception { assertThat(args.getString('z')).isEmpty(); } + @DisplayName("String 값이 없는 경우") + @Test + void simpleStringNotPresent() throws Exception { + //given + String schema = "x*"; + String[] arguments = new String[]{}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isZero(); + assertThat(args.has('x')).isFalse(); + assertThat(args.getString('x')).isEmpty(); + } + @DisplayName("String Argument 값이 없는 경우") @Test void missingStringArgument() throws Exception { @@ -183,20 +215,94 @@ void missingStringArgument() throws Exception { assertThat(args.errorMessage()).isEqualTo("Could not find string parameter for -x."); } - @DisplayName("Schema의 ElementId가 문자가 아니면 ParseException이 발생한다") + @DisplayName("int 값이 있는 경우") @Test - void throwParseExceptionWhenInvalidSchemaElementId() { + void simpleIntPresent() throws Exception { //given - String containsNonLetterElementId = "l,d*,#"; - String[] arguments = new String[0]; + String schema = "x#"; + String[] arguments = new String[]{"-x", "42"}; //when - Exception exception = catchException(() -> new Args(containsNonLetterElementId, arguments)); + Args args = new Args(schema, arguments); //then - assertThat(exception) - .isInstanceOf(ParseException.class) - .hasMessage("Bad character: # in Args format: l,d*,#"); + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isOne(); + assertThat(args.has('x')).isTrue(); + assertThat(args.getInt('x')).isEqualTo(42); + } + + @DisplayName("int 값이 여러 개 있는 경우") + @Test + void simpleIntMultiplePresent() throws Exception { + //given + String schema = "x#,y#,z#"; + String[] arguments = new String[]{"-x", "8001", "-y", "8002"}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isEqualTo(2); + assertThat(args.has('x')).isTrue(); + assertThat(args.has('y')).isTrue(); + assertThat(args.has('z')).isFalse(); + assertThat(args.getInt('x')).isEqualTo(8001); + assertThat(args.getInt('y')).isEqualTo(8002); + assertThat(args.getInt('z')).isZero(); + } + + @DisplayName("int 값이 없는 경우") + @Test + void simpleIntNotPresent() throws Exception { + //given + String schema = "x#"; + String[] arguments = new String[]{}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isZero(); + assertThat(args.has('x')).isFalse(); + assertThat(args.getInt('x')).isZero(); + } + + @DisplayName("Integer Argument 값이 없는 경우") + @Test + void missingInteger() throws Exception { + //given + String schema = "x#"; + String[] arguments = new String[]{"-x"}; // missing + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isFalse(); + assertThat(args.has('x')).isFalse(); + assertThat(args.getInt('x')).isZero(); + assertThat(args.errorMessage()).isEqualTo("Could not find integer parameter for -x."); + } + + @DisplayName("Integer Argument 값을 파싱할 수 없는 경우") + @Test + void invalidInteger() throws Exception { + //given + String schema = "x#"; + String[] arguments = new String[]{"-x", "Forty two"}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isFalse(); + assertThat(args.cardinality()).isZero(); + assertThat(args.has('x')).isFalse(); + assertThat(args.getInt('x')).isZero(); + assertThat(args.errorMessage()).isEqualTo("Argument -x expects an integer but was 'Forty two'."); } @DisplayName("유효한 args에서 errorMessage를 조회할 경우 Excpetion이 발생한다") From c7a916d25874ace04d91f87ce12f2962c169fefe Mon Sep 17 00:00:00 2001 From: viiviii Date: Wed, 11 May 2022 18:54:18 +0900 Subject: [PATCH 4/4] =?UTF-8?q?test:=20=EB=B9=A0=EC=A7=84=20=ED=85=8C?= =?UTF-8?q?=EC=8A=A4=ED=8A=B8spacesInFormat()=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/chapter14/args/ArgsTest.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/test/java/chapter14/args/ArgsTest.java b/src/test/java/chapter14/args/ArgsTest.java index 7cc50f5..8ca362f 100644 --- a/src/test/java/chapter14/args/ArgsTest.java +++ b/src/test/java/chapter14/args/ArgsTest.java @@ -89,6 +89,23 @@ void invalidArgumentFormat() { .hasMessage("Argument: f has invalid format: ~."); } + @DisplayName("Schema format에 스페이스가 있는 경우") + @Test + void spacesInFormat() throws Exception { + //given + String schema = "x, y"; + String[] arguments = new String[]{"-xy"}; + + //when + Args args = new Args(schema, arguments); + + //then + assertThat(args.isValid()).isTrue(); + assertThat(args.cardinality()).isEqualTo(2); + assertThat(args.has('x')).isTrue(); + assertThat(args.has('y')).isTrue(); + } + @DisplayName("boolean 값이 있는 경우") @Test void simpleBooleanPresent() throws Exception {