diff --git a/src/main/java/chapter14/Application.java b/src/main/java/chapter14/Application.java index ca77f84..e9acbe7 100644 --- a/src/main/java/chapter14/Application.java +++ b/src/main/java/chapter14/Application.java @@ -1,8 +1,7 @@ package chapter14; import chapter14.args.Args; - -import java.text.ParseException; +import chapter14.args.ArgsException; class Application { @@ -13,8 +12,8 @@ public static void main(String[] args) { int port = arg.getInt('p'); String directory = arg.getString('d'); executeApplication(logging, port, directory); - } catch (ParseException e) { - System.out.printf("Parse error: %s\n", e.getMessage()); + } catch (ArgsException e) { + System.out.printf("Argument error: %s\n", e.getMessage()); } } diff --git a/src/main/java/chapter14/args/Args.java b/src/main/java/chapter14/args/Args.java index e45390b..d3dd8bc 100644 --- a/src/main/java/chapter14/args/Args.java +++ b/src/main/java/chapter14/args/Args.java @@ -1,53 +1,35 @@ package chapter14.args; -import java.text.ParseException; import java.util.*; public class Args { private String schema; - private boolean valid = true; - private Set unexpectedArguments = new TreeSet<>(); private Map marshalers = new HashMap<>(); private Set argsFound = new HashSet<>(); private Iterator currentArgument; - private char errorArgumentId = '\0'; - private String errorParameter = "TILT"; - private ErrorCode errorCode = ErrorCode.OK; private List argsList; - enum ErrorCode { - OK, MISSING_STRING, MISSING_INTEGER, INVALID_INTEGER, - UNEXPECTED_ARGUMENT, MISSING_DOUBLE, INVALID_DOUBLE - } - - public Args(String schema, String[] args) throws ParseException { + public Args(String schema, String[] args) throws ArgsException { this.schema = schema; argsList = Arrays.asList(args); - valid = parse(); + parse(); } - private boolean parse() throws ParseException { - if (schema.length() == 0 && argsList.size() == 0) - return true; + private void parse() throws ArgsException { parseSchema(); - try { - parseArguments(); - } catch (ArgsException e) { - } - return valid; + parseArguments(); } - private boolean parseSchema() throws ParseException { + private boolean parseSchema() throws ArgsException { for (String element : schema.split(",")) { if (element.length() > 0) { - String trimmedElement = element.trim(); - parseSchemaElement(trimmedElement); + parseSchemaElement(element.trim()); } } return true; } - private void parseSchemaElement(String element) throws ParseException { + private void parseSchemaElement(String element) throws ArgsException { char elementId = element.charAt(0); String elementTail = element.substring(1); validateSchemaElementId(elementId); @@ -60,25 +42,23 @@ private void parseSchemaElement(String element) throws ParseException { } else if (elementTail.equals("##")) { marshalers.put(elementId, new DoubleArgumentMarshaler()); } else { - throw new ParseException( - String.format("Argument: %c has invalid format: %s.", - elementId, elementTail), 0); + throw new ArgsException(ArgsException.ErrorCode.INVALID_ARGUMENT_FORMAT, + elementId, elementTail); } } - private void validateSchemaElementId(char elementId) throws ParseException { + private void validateSchemaElementId(char elementId) throws ArgsException { if (!Character.isLetter(elementId)) { - throw new ParseException( - "Bad character: " + elementId + " in Args format: " + schema, 0); + throw new ArgsException(ArgsException.ErrorCode.INVALID_ARGUMENT_NAME, + elementId, null); } } - private boolean parseArguments() throws ArgsException { + private void parseArguments() throws ArgsException { for (currentArgument = argsList.iterator(); currentArgument.hasNext(); ) { String arg = currentArgument.next(); parseArgument(arg); } - return true; } private void parseArgument(String arg) throws ArgsException { @@ -96,9 +76,8 @@ private void parseElement(char argChar) throws ArgsException { if (setArgument(argChar)) argsFound.add(argChar); else { - unexpectedArguments.add(argChar); - errorCode = ErrorCode.UNEXPECTED_ARGUMENT; - valid = false; + throw new ArgsException(ArgsException.ErrorCode.UNEXPECTED_ARGUMENT, + argChar, null); } } @@ -110,8 +89,7 @@ private boolean setArgument(char argChar) throws ArgsException { m.set(currentArgument); return true; } catch (ArgsException e) { - valid = false; - errorArgumentId = argChar; + e.setErrorArgumentId(argChar); throw e; } } @@ -127,40 +105,15 @@ public String usage() { return ""; } - public String errorMessage() throws Exception { - 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); - case INVALID_DOUBLE: - return String.format("Argument -%c expects an double but was '%s'.", - errorArgumentId, errorParameter); - case MISSING_DOUBLE: - return String.format("Could not find double parameter for -%c.", - errorArgumentId); - } - return ""; - - } - - private String unexpectedArgumentMessage() { - StringBuffer message = new StringBuffer("Argument(s) -"); - for (char c : unexpectedArguments) { - message.append(c); + public boolean getBoolean(char arg) { + ArgumentMarshaler am = marshalers.get(arg); + boolean b = false; + try { + b = am != null && (Boolean) am.get(); + } catch (ClassCastException e) { + b = false; } - message.append(" unexpected."); - - return message.toString(); + return b; } public String getString(char arg) { @@ -181,17 +134,6 @@ public int getInt(char arg) { } } - public boolean getBoolean(char arg) { - ArgumentMarshaler am = marshalers.get(arg); - boolean b = false; - try { - b = am != null && (Boolean) am.get(); - } catch (ClassCastException e) { - b = false; - } - return b; - } - public double getDouble(char arg) { ArgumentMarshaler am = marshalers.get(arg); try { @@ -204,100 +146,4 @@ public double getDouble(char arg) { public boolean has(char arg) { return argsFound.contains(arg); } - - public boolean isValid() { - return valid; - } - - private class ArgsException extends Exception { - } - - private interface ArgumentMarshaler { - void set(Iterator currentArgument) throws ArgsException; - - Object get(); - } - - private class BooleanArgumentMarshaler implements ArgumentMarshaler { - private boolean booleanValue = false; - - @Override - public void set(Iterator currentArgument) throws ArgsException { - booleanValue = true; - } - - @Override - public Object get() { - return booleanValue; - } - } - - private class StringArgumentMarshaler implements ArgumentMarshaler { - private String stringValue = ""; - - @Override - public void set(Iterator currentArgument) throws ArgsException { - try { - stringValue = currentArgument.next(); - } catch (NoSuchElementException e) { - errorCode = ErrorCode.MISSING_STRING; - throw new ArgsException(); - } - } - - @Override - public Object get() { - return stringValue; - } - } - - private class IntegerArgumentMarshaler implements ArgumentMarshaler { - private int intValue = 0; - - @Override - public void set(Iterator currentArgument) throws ArgsException { - String parameter = null; - try { - parameter = currentArgument.next(); - intValue = Integer.parseInt(parameter); - } catch (NoSuchElementException e) { - errorCode = ErrorCode.MISSING_INTEGER; - throw new ArgsException(); - } catch (NumberFormatException e) { - errorParameter = parameter; - errorCode = ErrorCode.INVALID_INTEGER; - throw new ArgsException(); - } - } - - @Override - public Object get() { - return intValue; - } - } - - private class DoubleArgumentMarshaler implements ArgumentMarshaler { - private double doubleValue = 0; - - @Override - public void set(Iterator currentArgument) throws ArgsException { - String parameter = null; - try { - parameter = currentArgument.next(); - doubleValue = Double.parseDouble(parameter); - } catch (NoSuchElementException e) { - errorCode = ErrorCode.MISSING_DOUBLE; - throw new ArgsException(); - } catch (NumberFormatException e) { - errorParameter = parameter; - errorCode = ErrorCode.INVALID_DOUBLE; - throw new ArgsException(); - } - } - - @Override - public Object get() { - return doubleValue; - } - } } diff --git a/src/main/java/chapter14/args/ArgsException.java b/src/main/java/chapter14/args/ArgsException.java new file mode 100644 index 0000000..4e9addb --- /dev/null +++ b/src/main/java/chapter14/args/ArgsException.java @@ -0,0 +1,92 @@ +package chapter14.args; + +public class ArgsException extends Exception { + private char errorArgumentId = '\0'; + private String errorParameter = "TILT"; + private ErrorCode errorCode = ErrorCode.OK; + + public ArgsException() { + } + + public ArgsException(String message) { + super(message); + } + + public ArgsException(ErrorCode errorCode) { + this.errorCode = errorCode; + } + + public ArgsException(ErrorCode errorCode, String errorParameter) { + this.errorCode = errorCode; + this.errorParameter = errorParameter; + } + + public ArgsException(ErrorCode errorCode, char errorArgumentId, String errorParameter) { + this.errorCode = errorCode; + this.errorArgumentId = errorArgumentId; + this.errorParameter = errorParameter; + } + + public char getErrorArgumentId() { + return errorArgumentId; + } + + public void setErrorArgumentId(char errorArgumentId) { + this.errorArgumentId = errorArgumentId; + } + + public String getErrorParameter() { + return errorParameter; + } + + public void setErrorParameter(String errorParameter) { + this.errorParameter = errorParameter; + } + + public ErrorCode getErrorCode() { + return errorCode; + } + + public void setErrorCode(ErrorCode errorCode) { + this.errorCode = errorCode; + } + + public String errorMessage() throws Exception { + switch (errorCode) { + case OK: + throw new Exception("TILT: Should not get here."); + case UNEXPECTED_ARGUMENT: + return String.format("Argument(s) -%c unexpected.", errorArgumentId); + 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); + case INVALID_DOUBLE: + return String.format("Argument -%c expects an double but was '%s'.", + errorArgumentId, errorParameter); + case MISSING_DOUBLE: + return String.format("Could not find double parameter for -%c.", + errorArgumentId); + case INVALID_ARGUMENT_NAME: + return String.format("'%c' is not a valid argument name.", + errorArgumentId); + case INVALID_ARGUMENT_FORMAT: + return String.format("'%s' is not a valid argument format.", + errorParameter); + } + return ""; + } + + public enum ErrorCode { + OK, INVALID_ARGUMENT_FORMAT, UNEXPECTED_ARGUMENT, + INVALID_ARGUMENT_NAME, + MISSING_STRING, + MISSING_INTEGER, INVALID_INTEGER, + MISSING_DOUBLE, INVALID_DOUBLE + } +} diff --git a/src/main/java/chapter14/args/ArgumentMarshaler.java b/src/main/java/chapter14/args/ArgumentMarshaler.java new file mode 100644 index 0000000..8a641aa --- /dev/null +++ b/src/main/java/chapter14/args/ArgumentMarshaler.java @@ -0,0 +1,9 @@ +package chapter14.args; + +import java.util.Iterator; + +public interface ArgumentMarshaler { + void set(Iterator currentArgument) throws ArgsException; + + Object get(); +} diff --git a/src/main/java/chapter14/args/BooleanArgumentMarshaler.java b/src/main/java/chapter14/args/BooleanArgumentMarshaler.java new file mode 100644 index 0000000..4619a7e --- /dev/null +++ b/src/main/java/chapter14/args/BooleanArgumentMarshaler.java @@ -0,0 +1,17 @@ +package chapter14.args; + +import java.util.Iterator; + +public class BooleanArgumentMarshaler implements ArgumentMarshaler { + private boolean booleanValue = false; + + @Override + public void set(Iterator currentArgument) throws ArgsException { + booleanValue = true; + } + + @Override + public Object get() { + return booleanValue; + } +} \ No newline at end of file diff --git a/src/main/java/chapter14/args/DoubleArgumentMarshaler.java b/src/main/java/chapter14/args/DoubleArgumentMarshaler.java new file mode 100644 index 0000000..16544d3 --- /dev/null +++ b/src/main/java/chapter14/args/DoubleArgumentMarshaler.java @@ -0,0 +1,29 @@ +package chapter14.args; + +import java.util.Iterator; +import java.util.NoSuchElementException; + +import static chapter14.args.ArgsException.ErrorCode.INVALID_DOUBLE; +import static chapter14.args.ArgsException.ErrorCode.MISSING_DOUBLE; + +public class DoubleArgumentMarshaler implements ArgumentMarshaler { + private double doubleValue = 0; + + @Override + public void set(Iterator currentArgument) throws ArgsException { + String parameter = null; + try { + parameter = currentArgument.next(); + doubleValue = Double.parseDouble(parameter); + } catch (NoSuchElementException e) { + throw new ArgsException(MISSING_DOUBLE); + } catch (NumberFormatException e) { + throw new ArgsException(INVALID_DOUBLE, parameter); + } + } + + @Override + public Object get() { + return doubleValue; + } +} \ No newline at end of file diff --git a/src/main/java/chapter14/args/IntegerArgumentMarshaler.java b/src/main/java/chapter14/args/IntegerArgumentMarshaler.java new file mode 100644 index 0000000..ee040a5 --- /dev/null +++ b/src/main/java/chapter14/args/IntegerArgumentMarshaler.java @@ -0,0 +1,29 @@ +package chapter14.args; + +import java.util.Iterator; +import java.util.NoSuchElementException; + +import static chapter14.args.ArgsException.ErrorCode.INVALID_INTEGER; +import static chapter14.args.ArgsException.ErrorCode.MISSING_INTEGER; + +public class IntegerArgumentMarshaler implements ArgumentMarshaler { + private int intValue = 0; + + @Override + public void set(Iterator currentArgument) throws ArgsException { + String parameter = null; + try { + parameter = currentArgument.next(); + intValue = Integer.parseInt(parameter); + } catch (NoSuchElementException e) { + throw new ArgsException(MISSING_INTEGER); + } catch (NumberFormatException e) { + throw new ArgsException(INVALID_INTEGER, parameter); + } + } + + @Override + public Object get() { + return intValue; + } +} \ No newline at end of file diff --git a/src/main/java/chapter14/args/StringArgumentMarshaler.java b/src/main/java/chapter14/args/StringArgumentMarshaler.java new file mode 100644 index 0000000..2eef6d9 --- /dev/null +++ b/src/main/java/chapter14/args/StringArgumentMarshaler.java @@ -0,0 +1,24 @@ +package chapter14.args; + +import java.util.Iterator; +import java.util.NoSuchElementException; + +import static chapter14.args.ArgsException.ErrorCode.MISSING_STRING; + +public class StringArgumentMarshaler implements ArgumentMarshaler { + private String stringValue = ""; + + @Override + public void set(Iterator currentArgument) throws ArgsException { + try { + stringValue = currentArgument.next(); + } catch (NoSuchElementException e) { + throw new ArgsException(MISSING_STRING); + } + } + + @Override + public Object get() { + return stringValue; + } +} \ No newline at end of file diff --git a/src/test/java/chapter14/args/ArgsExceptionTest.java b/src/test/java/chapter14/args/ArgsExceptionTest.java new file mode 100644 index 0000000..a01faaf --- /dev/null +++ b/src/test/java/chapter14/args/ArgsExceptionTest.java @@ -0,0 +1,106 @@ +package chapter14.args; + +import org.junit.jupiter.api.Test; + +import static chapter14.args.ArgsException.ErrorCode; +import static chapter14.args.ArgsException.ErrorCode.*; +import static org.assertj.core.api.Assertions.assertThat; + +class ArgsExceptionTest { + + @Test + void unexpectedMessage() throws Exception { + //given + ErrorCode errorCode = UNEXPECTED_ARGUMENT; + + //when + ArgsException e = new ArgsException(errorCode, 'x', null); + + //then + assertThat(e.errorMessage()).isEqualTo("Argument(s) -x unexpected."); + } + + @Test + void missingStringMessage() throws Exception { + //given + ErrorCode errorCode = MISSING_STRING; + + //when + ArgsException e = new ArgsException(errorCode, 'x', null); + + //then + assertThat(e.errorMessage()).isEqualTo("Could not find string parameter for -x."); + } + + @Test + void invalidIntegerMessage() throws Exception { + //given + ErrorCode errorCode = INVALID_INTEGER; + + //when + ArgsException e = new ArgsException(errorCode, 'x', "Forty two"); + + //then + assertThat(e.errorMessage()).isEqualTo("Argument -x expects an integer but was 'Forty two'."); + } + + @Test + void missingIntegerMessage() throws Exception { + //given + ErrorCode errorCode = MISSING_INTEGER; + + //when + ArgsException e = new ArgsException(errorCode, 'x', null); + + //then + assertThat(e.errorMessage()).isEqualTo("Could not find integer parameter for -x."); + } + + @Test + void invalidDoubleMessage() throws Exception { + //given + ErrorCode errorCode = INVALID_DOUBLE; + + //when + ArgsException e = new ArgsException(errorCode, 'x', "Forty two"); + + //then + assertThat(e.errorMessage()).isEqualTo("Argument -x expects an double but was 'Forty two'."); + } + + @Test + void missingDoubleMessage() throws Exception { + //given + ErrorCode errorCode = MISSING_DOUBLE; + + //when + ArgsException e = new ArgsException(errorCode, 'x', null); + + //then + assertThat(e.errorMessage()).isEqualTo("Could not find double parameter for -x."); + } + + @Test + void invalidArgumentNameMessage() throws Exception { + //given + ErrorCode errorCode = INVALID_ARGUMENT_NAME; + + //when + ArgsException e = new ArgsException(errorCode, 'x', null); + + //then + assertThat(e.errorMessage()).isEqualTo("'x' is not a valid argument name."); + } + + @Test + void invalidArgumentFormatMessage() throws Exception { + //given + ErrorCode errorCode = INVALID_ARGUMENT_FORMAT; + + //when + ArgsException e = new ArgsException(errorCode, 'x', "f~"); + + //then + assertThat(e.errorMessage()).isEqualTo("'f~' is not a valid argument format."); + } +} \ No newline at end of file diff --git a/src/test/java/chapter14/args/ArgsTest.java b/src/test/java/chapter14/args/ArgsTest.java index fcfe149..b28ab04 100644 --- a/src/test/java/chapter14/args/ArgsTest.java +++ b/src/test/java/chapter14/args/ArgsTest.java @@ -3,8 +3,7 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import java.text.ParseException; - +import static chapter14.args.ArgsException.ErrorCode.*; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.catchException; @@ -21,40 +20,25 @@ void noSchemaAndArguments() throws Exception { Args args = new Args(schema, arguments); //then - assertThat(args.isValid()).isTrue(); assertThat(args.cardinality()).isZero(); } @DisplayName("schema가 없고 argument가 1개 있는 경우") @Test - void noSchemaButWithOneArgument() throws Exception { + void noSchemaButWithOneArgument() { //given String schema = ""; String[] arguments = new String[]{"-x"}; //when - Args args = new Args(schema, arguments); + Exception exception = catchException(() -> new Args(schema, arguments)); //then - assertThat(args.isValid()).isFalse(); - assertThat(args.cardinality()).isZero(); - assertThat(args.errorMessage()).isEqualTo("Argument(s) -x unexpected."); - } - - @DisplayName("schema가 없고 argument가 여러 개 있는 경우") - @Test - void noSchemaButWithMultipleArguments() throws Exception { - //given - String schema = ""; - String[] arguments = new String[]{"-x", "-y"}; - - //when - Args args = new Args(schema, arguments); + assertThat(exception).isInstanceOf(ArgsException.class); - //then - assertThat(args.isValid()).isFalse(); - assertThat(args.cardinality()).isZero(); - assertThat(args.errorMessage()).isEqualTo("Argument(s) -xy unexpected."); + ArgsException e = (ArgsException) exception; + assertThat(e.getErrorCode()).isEqualTo(UNEXPECTED_ARGUMENT); + assertThat(e.getErrorArgumentId()).isEqualTo('x'); } @DisplayName("Schema가 있고, arugment가 없는 경우") @@ -68,7 +52,6 @@ void multipleSchemasButNoArguments() throws Exception { Args args = new Args(schema, arguments); //then - assertThat(args.isValid()).isTrue(); assertThat(args.cardinality()).isZero(); assertThat(args.has('x')).isFalse(); assertThat(args.has('y')).isFalse(); @@ -89,9 +72,11 @@ void nonLetterSchema() { Exception exception = catchException(() -> new Args(nonLetterSchemaElementId, arguments)); //then - assertThat(exception) - .isInstanceOf(ParseException.class) - .hasMessage("Bad character: * in Args format: *"); + assertThat(exception).isInstanceOf(ArgsException.class); + + ArgsException e = (ArgsException) exception; + assertThat(e.getErrorCode()).isEqualTo(INVALID_ARGUMENT_NAME); + assertThat(e.getErrorArgumentId()).isEqualTo('*'); } @DisplayName("schema format이 유효하지 않은 경우") @@ -105,9 +90,11 @@ void invalidArgumentFormat() { Exception exception = catchException(() -> new Args(invalidSchemeFormat, arguments)); //then - assertThat(exception) - .isInstanceOf(ParseException.class) - .hasMessage("Argument: f has invalid format: ~."); + assertThat(exception).isInstanceOf(ArgsException.class); + + ArgsException e = (ArgsException) exception; + assertThat(e.getErrorCode()).isEqualTo(INVALID_ARGUMENT_FORMAT); + assertThat(e.getErrorArgumentId()).isEqualTo('f'); } @DisplayName("Schema format에 스페이스가 있는 경우") @@ -121,7 +108,6 @@ void spacesInFormat() throws Exception { 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(); @@ -138,7 +124,6 @@ void simpleBooleanPresent() throws Exception { Args args = new Args(schema, arguments); //then - assertThat(args.isValid()).isTrue(); assertThat(args.cardinality()).isOne(); assertThat(args.getBoolean('x')).isTrue(); } @@ -154,7 +139,6 @@ void simpleBooleanMultiplePresent() throws Exception { 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(); @@ -188,7 +172,6 @@ void simpleStringPresent() throws Exception { Args args = new Args(schema, arguments); //then - assertThat(args.isValid()).isTrue(); assertThat(args.cardinality()).isOne(); assertThat(args.has('x')).isTrue(); assertThat(args.getString('x')).isEqualTo("param"); @@ -205,7 +188,6 @@ void simpleStringMultiplePresent() throws Exception { 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(); @@ -228,22 +210,6 @@ void simpleStringNotPresent() throws Exception { assertThat(actual).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.getString('x')).isEmpty(); - assertThat(args.errorMessage()).isEqualTo("Could not find string parameter for -x."); - } - @DisplayName("int 값이 있는 경우") @Test void simpleIntPresent() throws Exception { @@ -255,7 +221,6 @@ void simpleIntPresent() throws Exception { Args args = new Args(schema, arguments); //then - assertThat(args.isValid()).isTrue(); assertThat(args.cardinality()).isOne(); assertThat(args.has('x')).isTrue(); assertThat(args.getInt('x')).isEqualTo(42); @@ -272,7 +237,6 @@ void simpleIntMultiplePresent() throws Exception { 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(); @@ -295,40 +259,6 @@ void simpleIntNotPresent() throws Exception { assertThat(actual).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.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("double 값이 있는 경우") @Test void simpleDoublePresent() throws Exception { @@ -340,7 +270,6 @@ void simpleDoublePresent() throws Exception { Args args = new Args(schema, arguments); //then - assertThat(args.isValid()).isTrue(); assertThat(args.cardinality()).isOne(); assertThat(args.has('x')).isTrue(); assertThat(args.getDouble('x')).isEqualTo(42.3); @@ -359,42 +288,6 @@ void simpleDoubleNotPresent() throws Exception { assertThat(actual).isZero(); } - @DisplayName("Double Argument 값이 없는 경우") - @Test - void missingDouble() 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()).isZero(); - assertThat(args.has('x')).isFalse(); - assertThat(args.getDouble('x')).isZero(); - assertThat(args.errorMessage()).isEqualTo("Could not find double parameter for -x."); - } - - @DisplayName("Double Argument 값을 파싱할 수 없는 경우") - @Test - void invalidDouble() 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.getDouble('x')).isZero(); - assertThat(args.errorMessage()).isEqualTo("Argument -x expects an double but was 'Forty two'."); - } - @DisplayName("잘못된 타입으로 호출한 경우") @Test void invalidType() throws Exception { @@ -411,20 +304,4 @@ void invalidType() throws Exception { assertThat(args.getInt('y')).isZero(); // y is type String assertThat(args.getDouble('y')).isZero(); // y is type String } - - @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 diff --git a/src/test/java/chapter14/args/DoubleArgumentMarshalerTest.java b/src/test/java/chapter14/args/DoubleArgumentMarshalerTest.java new file mode 100644 index 0000000..609941e --- /dev/null +++ b/src/test/java/chapter14/args/DoubleArgumentMarshalerTest.java @@ -0,0 +1,48 @@ +package chapter14.args; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.catchException; + +class DoubleArgumentMarshalerTest { + private ArgumentMarshaler am = new DoubleArgumentMarshaler(); + + @DisplayName("값을 파싱할 수 없는 경우") + @Test + void invalidDouble() { + //given + Iterator argument = List.of("Forty two").iterator(); + + //when + Exception exception = catchException(() -> am.set(argument)); + + //then + assertThat(exception).isInstanceOf(ArgsException.class); + + ArgsException e = (ArgsException) exception; + assertThat(e.getErrorCode()).isEqualTo(ArgsException.ErrorCode.INVALID_DOUBLE); + assertThat(e.getErrorParameter()).isEqualTo("Forty two"); + } + + @DisplayName("Argument 값이 없는 경우") + @Test + void missingDouble() { + //given + Iterator argument = Collections.emptyIterator(); + + //when + Exception exception = catchException(() -> am.set(argument)); + + //then + assertThat(exception).isInstanceOf(ArgsException.class); + + ArgsException e = (ArgsException) exception; + assertThat(e.getErrorCode()).isEqualTo(ArgsException.ErrorCode.MISSING_DOUBLE); + } +} \ No newline at end of file diff --git a/src/test/java/chapter14/args/IntegerArgumentMarshalerTest.java b/src/test/java/chapter14/args/IntegerArgumentMarshalerTest.java new file mode 100644 index 0000000..9135c20 --- /dev/null +++ b/src/test/java/chapter14/args/IntegerArgumentMarshalerTest.java @@ -0,0 +1,48 @@ +package chapter14.args; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.catchException; + +class IntegerArgumentMarshalerTest { + private ArgumentMarshaler am = new IntegerArgumentMarshaler(); + + @DisplayName("Integer Argument 값을 파싱할 수 없는 경우") + @Test + void invalidInteger() { + //given + Iterator argument = List.of("Forty two").iterator(); + + //when + Exception exception = catchException(() -> am.set(argument)); + + //then + assertThat(exception).isInstanceOf(ArgsException.class); + + ArgsException e = (ArgsException) exception; + assertThat(e.getErrorCode()).isEqualTo(ArgsException.ErrorCode.INVALID_INTEGER); + assertThat(e.getErrorParameter()).isEqualTo("Forty two"); + } + + @DisplayName("Argument 값이 없는 경우") + @Test + void missingInteger() { + //given + Iterator argument = Collections.emptyIterator(); + + //when + Exception exception = catchException(() -> am.set(argument)); + + //then + assertThat(exception).isInstanceOf(ArgsException.class); + + ArgsException e = (ArgsException) exception; + assertThat(e.getErrorCode()).isEqualTo(ArgsException.ErrorCode.MISSING_INTEGER); + } +} \ No newline at end of file diff --git a/src/test/java/chapter14/args/StringArgumentMarshalerTest.java b/src/test/java/chapter14/args/StringArgumentMarshalerTest.java new file mode 100644 index 0000000..9f7772c --- /dev/null +++ b/src/test/java/chapter14/args/StringArgumentMarshalerTest.java @@ -0,0 +1,30 @@ +package chapter14.args; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.Iterator; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.catchException; + +class StringArgumentMarshalerTest { + private ArgumentMarshaler am = new StringArgumentMarshaler(); + + @DisplayName("Argument 값이 없는 경우") + @Test + void missingString() { + //given + Iterator argument = Collections.emptyIterator(); + + //when + Exception exception = catchException(() -> am.set(argument)); + + //then + assertThat(exception).isInstanceOf(ArgsException.class); + + ArgsException e = (ArgsException) exception; + assertThat(e.getErrorCode()).isEqualTo(ArgsException.ErrorCode.MISSING_STRING); + } +} \ No newline at end of file