From 557352f289be5b2999914ba0df7310e0b636ff96 Mon Sep 17 00:00:00 2001 From: Nathan Adams Date: Thu, 16 Nov 2017 14:31:50 +0100 Subject: [PATCH] Added double argument type --- .../arguments/DoubleArgumentType.java | 84 +++++++++++++++++++ .../arguments/DoubleArgumentTypeTest.java | 82 ++++++++++++++++++ 2 files changed, 166 insertions(+) create mode 100644 src/main/java/com/mojang/brigadier/arguments/DoubleArgumentType.java create mode 100644 src/test/java/com/mojang/brigadier/arguments/DoubleArgumentTypeTest.java diff --git a/src/main/java/com/mojang/brigadier/arguments/DoubleArgumentType.java b/src/main/java/com/mojang/brigadier/arguments/DoubleArgumentType.java new file mode 100644 index 0000000..fb115c9 --- /dev/null +++ b/src/main/java/com/mojang/brigadier/arguments/DoubleArgumentType.java @@ -0,0 +1,84 @@ +package com.mojang.brigadier.arguments; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.context.CommandContextBuilder; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.exceptions.ParameterizedCommandExceptionType; + +public class DoubleArgumentType implements ArgumentType { + public static final ParameterizedCommandExceptionType ERROR_TOO_SMALL = new ParameterizedCommandExceptionType("argument.double.low", "Double must not be less than ${minimum}, found ${found}", "found", "minimum"); + public static final ParameterizedCommandExceptionType ERROR_TOO_BIG = new ParameterizedCommandExceptionType("argument.double.big", "Double must not be more than ${maximum}, found ${found}", "found", "maximum"); + + private final double minimum; + private final double maximum; + + private DoubleArgumentType(final double minimum, final double maximum) { + this.minimum = minimum; + this.maximum = maximum; + } + + public static DoubleArgumentType doubleArg() { + return doubleArg(-Double.MAX_VALUE); + } + + public static DoubleArgumentType doubleArg(final double min) { + return doubleArg(min, Double.MAX_VALUE); + } + + public static DoubleArgumentType doubleArg(final double min, final double max) { + return new DoubleArgumentType(min, max); + } + + public static double getDouble(final CommandContext context, final String name) { + return context.getArgument(name, Double.class); + } + + public double getMinimum() { + return minimum; + } + + public double getMaximum() { + return maximum; + } + + @Override + public Double parse(final StringReader reader, final CommandContextBuilder contextBuilder) throws CommandSyntaxException { + final int start = reader.getCursor(); + final double result = reader.readDouble(); + if (result < minimum) { + reader.setCursor(start); + throw ERROR_TOO_SMALL.createWithContext(reader, result, minimum); + } + if (result > maximum) { + reader.setCursor(start); + throw ERROR_TOO_BIG.createWithContext(reader, result, maximum); + } + return result; + } + + @Override + public boolean equals(final Object o) { + if (this == o) return true; + if (!(o instanceof DoubleArgumentType)) return false; + + final DoubleArgumentType that = (DoubleArgumentType) o; + return maximum == that.maximum && minimum == that.minimum; + } + + @Override + public int hashCode() { + return (int) (31 * minimum + maximum); + } + + @Override + public String toString() { + if (minimum == -Double.MAX_VALUE && maximum == Double.MAX_VALUE) { + return "double()"; + } else if (maximum == Double.MAX_VALUE) { + return "double(" + minimum + ")"; + } else { + return "double(" + minimum + ", " + maximum + ")"; + } + } +} diff --git a/src/test/java/com/mojang/brigadier/arguments/DoubleArgumentTypeTest.java b/src/test/java/com/mojang/brigadier/arguments/DoubleArgumentTypeTest.java new file mode 100644 index 0000000..148f714 --- /dev/null +++ b/src/test/java/com/mojang/brigadier/arguments/DoubleArgumentTypeTest.java @@ -0,0 +1,82 @@ +package com.mojang.brigadier.arguments; + +import com.google.common.collect.ImmutableMap; +import com.google.common.testing.EqualsTester; +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.context.CommandContextBuilder; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; + +import static com.mojang.brigadier.arguments.DoubleArgumentType.doubleArg; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.hasToString; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; + +@RunWith(MockitoJUnitRunner.class) +public class DoubleArgumentTypeTest { + private DoubleArgumentType type; + @Mock + private CommandContextBuilder context; + + @Before + public void setUp() throws Exception { + type = doubleArg(-100, 100); + } + + @Test + public void parse() throws Exception { + final StringReader reader = new StringReader("15"); + assertThat(doubleArg().parse(reader, context), is(15.0)); + assertThat(reader.canRead(), is(false)); + } + + @Test + public void parse_tooSmall() throws Exception { + final StringReader reader = new StringReader("-5"); + try { + doubleArg(0, 100).parse(reader, context); + fail(); + } catch (final CommandSyntaxException ex) { + assertThat(ex.getType(), is(DoubleArgumentType.ERROR_TOO_SMALL)); + assertThat(ex.getData(), equalTo(ImmutableMap.of("found", "-5.0", "minimum", "0.0"))); + assertThat(ex.getCursor(), is(0)); + } + } + + @Test + public void parse_tooBig() throws Exception { + final StringReader reader = new StringReader("5"); + try { + doubleArg(-100, 0).parse(reader, context); + fail(); + } catch (final CommandSyntaxException ex) { + assertThat(ex.getType(), is(DoubleArgumentType.ERROR_TOO_BIG)); + assertThat(ex.getData(), equalTo(ImmutableMap.of("found", "5.0", "maximum", "0.0"))); + assertThat(ex.getCursor(), is(0)); + } + } + + @Test + public void testEquals() throws Exception { + new EqualsTester() + .addEqualityGroup(doubleArg(), doubleArg()) + .addEqualityGroup(doubleArg(-100, 100), doubleArg(-100, 100)) + .addEqualityGroup(doubleArg(-100, 50), doubleArg(-100, 50)) + .addEqualityGroup(doubleArg(-50, 100), doubleArg(-50, 100)) + .testEquals(); + } + + @Test + public void testToString() throws Exception { + assertThat(doubleArg(), hasToString("double()")); + assertThat(doubleArg(-100), hasToString("double(-100.0)")); + assertThat(doubleArg(-100, 100), hasToString("double(-100.0, 100.0)")); + assertThat(doubleArg(Integer.MIN_VALUE, 100), hasToString("double(-2.147483648E9, 100.0)")); + } +} \ No newline at end of file