mirror of
https://github.com/Minestom/Minestom.git
synced 2024-06-20 11:34:53 +02:00
Simplify command tests
Signed-off-by: TheMode <themode@outlook.fr>
This commit is contained in:
TheMode
parent
23f03258b9
commit
5193529702
|
|
@ -8,11 +8,13 @@ import org.junit.jupiter.api.Test;
|
|||
|
||||
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
||||
|
||||
/**
|
||||
* Test string version of arguments.
|
||||
*/
|
||||
public class ArgumentParserTest {
|
||||
|
||||
@Test
|
||||
public void testArgumentParser() {
|
||||
|
||||
// Test each argument
|
||||
assertParserEquals("Literal<example>", ArgumentType.Literal("example"));
|
||||
assertParserEquals("Boolean<example>", ArgumentType.Boolean("example"));
|
||||
|
|
@ -54,5 +56,4 @@ public class ArgumentParserTest {
|
|||
private static void assertParserEquals(@NotNull String input, @NotNull Argument<?> @NotNull ... args) {
|
||||
assertArrayEquals(ArgumentParser.generate(input), args);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,7 +24,8 @@ public class ArgumentTest {
|
|||
var arg = ArgumentType.String("id");
|
||||
|
||||
assertFalse(arg.hasErrorCallback());
|
||||
arg.setCallback((sender, exception) -> {});
|
||||
arg.setCallback((sender, exception) -> {
|
||||
});
|
||||
assertTrue(arg.hasErrorCallback());
|
||||
}
|
||||
|
||||
|
|
@ -52,5 +53,4 @@ public class ArgumentTest {
|
|||
|
||||
assertEquals(suggestion.getEntries(), List.of(new SuggestionEntry("entry")));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -5,8 +5,7 @@ import net.kyori.adventure.text.format.NamedTextColor;
|
|||
import net.kyori.adventure.text.format.Style;
|
||||
import net.kyori.adventure.text.format.TextDecoration;
|
||||
import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
|
||||
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
|
||||
import net.minestom.server.command.builder.CommandContext;
|
||||
import net.minestom.server.command.builder.arguments.Argument;
|
||||
import net.minestom.server.command.builder.arguments.ArgumentEnum;
|
||||
import net.minestom.server.command.builder.arguments.ArgumentType;
|
||||
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
|
||||
|
|
@ -37,91 +36,65 @@ public class ArgumentTypeTest {
|
|||
@Test
|
||||
public void testArgumentEnchantment() {
|
||||
var arg = ArgumentType.Enchantment("enchantment");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("minecraft:invalid_enchantment"));
|
||||
assertNotEquals(Enchantment.RESPIRATION, arg.parse(Enchantment.SWEEPING.namespace().asString()));
|
||||
assertEquals(Enchantment.MENDING, arg.parse(Enchantment.MENDING.namespace().asString()));
|
||||
|
||||
assertEquals("Enchantment<enchantment>", arg.toString());
|
||||
assertInvalidArg(arg, "minecraft:invalid_enchantment");
|
||||
assertArg(arg, Enchantment.SWEEPING, Enchantment.SWEEPING.name());
|
||||
assertArg(arg, Enchantment.MENDING, Enchantment.MENDING.name());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentEntityType() {
|
||||
var arg = ArgumentType.EntityType("entity_type");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("minecraft:invalid_entity_type"));
|
||||
assertNotEquals(EntityType.ARMOR_STAND, arg.parse(EntityType.HUSK.namespace().asString()));
|
||||
assertEquals(EntityType.PLAYER, arg.parse(EntityType.PLAYER.namespace().asString()));
|
||||
|
||||
|
||||
assertEquals("EntityType<entity_type>", arg.toString());
|
||||
assertInvalidArg(arg, "minecraft:invalid_entity_type");
|
||||
assertArg(arg, EntityType.ARMOR_STAND, EntityType.ARMOR_STAND.name());
|
||||
assertArg(arg, EntityType.PLAYER, EntityType.PLAYER.name());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentParticle() {
|
||||
var arg = ArgumentType.Particle("particle");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("minecraft:invalid_particle"));
|
||||
assertNotEquals(Particle.BLOCK, arg.parse(Particle.CAMPFIRE_SIGNAL_SMOKE.namespace().asString()));
|
||||
assertEquals(Particle.TOTEM_OF_UNDYING, arg.parse(Particle.TOTEM_OF_UNDYING.namespace().asString()));
|
||||
|
||||
assertEquals("Particle<particle>", arg.toString());
|
||||
assertInvalidArg(arg, "minecraft:invalid_particle");
|
||||
assertArg(arg, Particle.BLOCK, Particle.BLOCK.name());
|
||||
assertArg(arg, Particle.TOTEM_OF_UNDYING, Particle.TOTEM_OF_UNDYING.name());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentPotionEffect() {
|
||||
var arg = ArgumentType.Potion("potion");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("minecraft:invalid_potion"));
|
||||
assertNotEquals(PotionEffect.SPEED, arg.parse(PotionEffect.JUMP_BOOST.namespace().asString()));
|
||||
assertEquals(PotionEffect.INSTANT_DAMAGE, arg.parse(PotionEffect.INSTANT_DAMAGE.namespace().asString()));
|
||||
|
||||
assertEquals("Potion<potion>", arg.toString());
|
||||
assertInvalidArg(arg, "minecraft:invalid_potion");
|
||||
assertArg(arg, PotionEffect.JUMP_BOOST, PotionEffect.JUMP_BOOST.name());
|
||||
assertArg(arg, PotionEffect.INSTANT_DAMAGE, PotionEffect.INSTANT_DAMAGE.name());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentBlockState() {
|
||||
var arg = ArgumentType.BlockState("block_state");
|
||||
assertInvalidArg(arg, "minecraft:invalid_block[invalid_property=invalid_key]");
|
||||
assertInvalidArg(arg, "minecraft:stone[invalid_property=invalid_key]");
|
||||
assertInvalidArg(arg, "minecraft:kelp[age=invalid_key]");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("minecraft:invalid_block[invalid_property=invalid_key]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("minecraft:stone[invalid_property=invalid_key]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("minecraft:kelp[age=invalid_key]"));
|
||||
assertEquals(Block.COBBLESTONE, arg.parse("minecraft:cobblestone"));
|
||||
assertEquals(Block.KELP.withProperty("age", "14"), arg.parse("minecraft:kelp[age=14]"));
|
||||
assertNotEquals(Block.KELP.withProperty("age", "15"), arg.parse("minecraft:kelp[age=14]"));
|
||||
assertNotEquals(Block.ATTACHED_MELON_STEM, arg.parse("minecraft:cobblestone"));
|
||||
|
||||
assertEquals("BlockState<block_state>", arg.toString());
|
||||
assertArg(arg, Block.COBBLESTONE, "minecraft:cobblestone");
|
||||
assertArg(arg, Block.KELP.withProperty("age", "14"), "minecraft:kelp[age=14]");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentColor() {
|
||||
var arg = ArgumentType.Color("color");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("invalid_color"));
|
||||
assertNotEquals(Style.style(NamedTextColor.AQUA), arg.parse("blue"));
|
||||
assertEquals(Style.style(NamedTextColor.DARK_PURPLE), arg.parse("dark_purple"));
|
||||
assertEquals(Style.empty(), arg.parse("reset"));
|
||||
|
||||
assertEquals("Color<color>", arg.toString());
|
||||
assertInvalidArg(arg, "invalid_color");
|
||||
assertArg(arg, Style.style(NamedTextColor.DARK_PURPLE), "dark_purple");
|
||||
assertArg(arg, Style.empty(), "reset");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentComponent() {
|
||||
var arg = ArgumentType.Component("component");
|
||||
|
||||
var component1 = Component.text("Example text", NamedTextColor.DARK_AQUA);
|
||||
var component2 = Component.text("Other example text", Style.style(TextDecoration.OBFUSCATED));
|
||||
|
||||
var json1 = GsonComponentSerializer.gson().serialize(component1);
|
||||
var json2 = GsonComponentSerializer.gson().serialize(component2);
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("invalid component"));
|
||||
assertNotEquals(component1, arg.parse(json2));
|
||||
assertEquals(component1, arg.parse(json1));
|
||||
assertEquals("Other example text", PlainTextComponentSerializer.plainText().serialize(arg.parse(json2)));
|
||||
|
||||
assertEquals("Component<component>", arg.toString());
|
||||
assertInvalidArg(arg, "invalid component");
|
||||
assertArg(arg, component1, json1);
|
||||
assertArg(arg, component2, json2);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -130,329 +103,277 @@ public class ArgumentTypeTest {
|
|||
|
||||
assertDoesNotThrow(() -> arg.parse("@a"));
|
||||
assertDoesNotThrow(() -> arg.parse("@p"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@x"));
|
||||
assertInvalidArg(arg, "@x");
|
||||
|
||||
assertDoesNotThrow(() -> arg.parse("@e[type=sheep]"));
|
||||
assertDoesNotThrow(() -> arg.parse("@e[type=!cow]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[type=invalid_entity]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[type=!invalid_entity_two]"));
|
||||
assertInvalidArg(arg, "@e[type=invalid_entity]");
|
||||
assertInvalidArg(arg, "@e[type=!invalid_entity_two]");
|
||||
|
||||
assertDoesNotThrow(() -> arg.parse("@e[gamemode=creative]"));
|
||||
assertDoesNotThrow(() -> arg.parse("@e[gamemode=!survival]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[gamemode=invalid_gamemode]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[gamemode=!invalid_gamemode_2]"));
|
||||
assertInvalidArg(arg, "@e[gamemode=invalid_gamemode]");
|
||||
assertInvalidArg(arg, "@e[gamemode=!invalid_gamemode_2]");
|
||||
|
||||
assertDoesNotThrow(() -> arg.parse("@e[limit=500]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[limit=-500]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[limit=invalid_integer]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[limit=2147483648]"));
|
||||
assertInvalidArg(arg, "@e[limit=-500]");
|
||||
assertInvalidArg(arg, "@e[limit=invalid_integer]");
|
||||
assertInvalidArg(arg, "@e[limit=2147483648]");
|
||||
|
||||
assertDoesNotThrow(() -> arg.parse("@e[sort=nearest]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[sort=invalid_sort]"));
|
||||
assertInvalidArg(arg, "@e[sort=invalid_sort]");
|
||||
|
||||
assertDoesNotThrow(() -> arg.parse("@e[level=55]"));
|
||||
assertDoesNotThrow(() -> arg.parse("@e[level=100..500]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[level=20-50]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[level=2147483648]"));
|
||||
assertInvalidArg(arg, "@e[level=20-50]");
|
||||
assertInvalidArg(arg, "@e[level=2147483648]");
|
||||
|
||||
assertDoesNotThrow(() -> arg.parse("@e[distance=500]"));
|
||||
assertDoesNotThrow(() -> arg.parse("@e[distance=50..150]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[distance=-500-500]"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("@e[distance=2147483648]"));
|
||||
|
||||
assertEquals("Entities<entity>", arg.toString());
|
||||
assertInvalidArg(arg, "@e[distance=-500-500]");
|
||||
assertInvalidArg(arg, "@e[distance=2147483648]");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentFloatRange() {
|
||||
var arg = ArgumentType.FloatRange("float_range");
|
||||
|
||||
assertEquals(new FloatRange(0f, 50f), arg.parse("0..50"));
|
||||
assertEquals(new FloatRange(0f, 0f), arg.parse("0..0"));
|
||||
assertEquals(new FloatRange(-50f, 0f), arg.parse("-50..0"));
|
||||
assertEquals(new FloatRange(-Float.MAX_VALUE, 50f), arg.parse("..50"));
|
||||
assertEquals(new FloatRange(0f, Float.MAX_VALUE), arg.parse("0.."));
|
||||
assertEquals(new FloatRange(-Float.MAX_VALUE, Float.MAX_VALUE), arg.parse("-3.4028235E38..3.4028235E38"));
|
||||
assertEquals(new FloatRange(0.5f, 24f), arg.parse("0.5..24"));
|
||||
assertEquals(new FloatRange(12f, 45.6f), arg.parse("12..45.6"));
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse(".."));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("0..50.."));
|
||||
|
||||
assertEquals("FloatRange<float_range>", arg.toString());
|
||||
assertArg(arg, new FloatRange(0f, 50f), "0..50");
|
||||
assertArg(arg, new FloatRange(0f, 0f), "0..0");
|
||||
assertArg(arg, new FloatRange(-50f, 0f), "-50..0");
|
||||
assertArg(arg, new FloatRange(-Float.MAX_VALUE, 50f), "..50");
|
||||
assertArg(arg, new FloatRange(0f, Float.MAX_VALUE), "0..");
|
||||
assertArg(arg, new FloatRange(-Float.MAX_VALUE, Float.MAX_VALUE), "-3.4028235E38..3.4028235E38");
|
||||
assertArg(arg, new FloatRange(0.5f, 24f), "0.5..24");
|
||||
assertArg(arg, new FloatRange(12f, 45.6f), "12..45.6");
|
||||
assertInvalidArg(arg, "..");
|
||||
assertInvalidArg(arg, "0..50..");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentIntRange() {
|
||||
var arg = ArgumentType.IntRange("int_range");
|
||||
|
||||
assertEquals(new IntRange(0, 50), arg.parse("0..50"));
|
||||
assertEquals(new IntRange(0, 0), arg.parse("0..0"));
|
||||
assertEquals(new IntRange(-50, 0), arg.parse("-50..0"));
|
||||
assertEquals(new IntRange(Integer.MIN_VALUE, 50), arg.parse("..50"));
|
||||
assertEquals(new IntRange(0, Integer.MAX_VALUE), arg.parse("0.."));
|
||||
assertEquals(new IntRange(Integer.MIN_VALUE, Integer.MAX_VALUE), arg.parse("-2147483648..2147483647"));
|
||||
assertArg(arg, new IntRange(0, 50), "0..50");
|
||||
assertArg(arg, new IntRange(0, 0), "0..0");
|
||||
assertArg(arg, new IntRange(-50, 0), "-50..0");
|
||||
assertArg(arg, new IntRange(Integer.MIN_VALUE, 50), "..50");
|
||||
assertArg(arg, new IntRange(0, Integer.MAX_VALUE), "0..");
|
||||
assertArg(arg, new IntRange(Integer.MIN_VALUE, Integer.MAX_VALUE), "-2147483648..2147483647");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse(".."));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-2147483649..2147483647"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-2147483648..2147483648"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("0..50.."));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("0.5..24"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("12..45.6"));
|
||||
|
||||
assertEquals("IntRange<int_range>", arg.toString());
|
||||
assertInvalidArg(arg, "..");
|
||||
assertInvalidArg(arg, "-2147483649..2147483647");
|
||||
assertInvalidArg(arg, "-2147483648..2147483648");
|
||||
assertInvalidArg(arg, "0..50..");
|
||||
assertInvalidArg(arg, "0.5..24");
|
||||
assertInvalidArg(arg, "12..45.6");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentItemStack() {
|
||||
var arg = ArgumentType.ItemStack("item_stack");
|
||||
|
||||
assertEquals(ItemStack.AIR, arg.parse("air"));
|
||||
assertEquals(ItemStack.of(Material.GLASS_PANE).withTag(Tag.String("tag"), "value"), arg.parse("glass_pane{tag:value}"));
|
||||
|
||||
assertEquals("ItemStack<item_stack>", arg.toString());
|
||||
assertArg(arg, ItemStack.AIR, "air");
|
||||
assertArg(arg, ItemStack.of(Material.GLASS_PANE).withTag(Tag.String("tag"), "value"), "glass_pane{tag:value}");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentNbtCompoundTag() {
|
||||
var arg = ArgumentType.NbtCompound("nbt_compound");
|
||||
assertArg(arg, NBT.Compound(mut -> mut.put("long_array", NBT.LongArray(12, 49, 119))), "{\"long_array\":[L;12L,49L,119L]}");
|
||||
assertArg(arg, NBT.Compound(mut -> mut.put("nested", NBT.Compound(mut2 ->
|
||||
mut2.put("complex", NBT.IntArray(124, 999, 33256))
|
||||
))
|
||||
), "{\"nested\": {\"complex\": [I;124,999,33256]}}");
|
||||
|
||||
assertEquals(NBT.Compound(mut -> mut.put("long_array", NBT.LongArray(12, 49, 119))), arg.parse("{\"long_array\":[L;12L,49L,119L]}"));
|
||||
assertEquals(NBT.Compound(mut -> mut.put("nested", NBT.Compound(mut2 ->
|
||||
mut2.put("complex", NBT.IntArray(124, 999, 33256))
|
||||
))
|
||||
), arg.parse("{\"nested\": {\"complex\": [I;124,999,33256]}}"));
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("string"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("\"string\""));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("44"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("[I;11,49,33]"));
|
||||
|
||||
assertEquals("NbtCompound<nbt_compound>", arg.toString());
|
||||
assertInvalidArg(arg, "string");
|
||||
assertInvalidArg(arg, "\"string\"");
|
||||
assertInvalidArg(arg, "44");
|
||||
assertInvalidArg(arg, "[I;11,49,33]");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentNbtTag() {
|
||||
var arg = ArgumentType.NBT("nbt");
|
||||
assertArg(arg, NBT.String("string"), "string");
|
||||
assertArg(arg, NBT.String("string"), "\"string\"");
|
||||
assertArg(arg, NBT.Int(44), "44");
|
||||
assertArg(arg, NBT.IntArray(11, 49, 33), "[I;11,49,33]");
|
||||
assertArg(arg, NBT.Compound(mut -> mut.put("long_array", NBT.LongArray(12, 49, 119))), "{\"long_array\":[L;12L,49L,119L]}");
|
||||
|
||||
assertEquals(NBT.String("string"), arg.parse("string"));
|
||||
assertEquals(NBT.String("string"), arg.parse("\"string\""));
|
||||
assertEquals(NBT.Int(44), arg.parse("44"));
|
||||
assertEquals(NBT.IntArray(11, 49, 33), arg.parse("[I;11,49,33]"));
|
||||
assertEquals(NBT.Compound(mut -> mut.put("long_array", NBT.LongArray(12, 49, 119))), arg.parse("{\"long_array\":[L;12L,49L,119L]}"));
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("\"unbalanced string"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("dd}"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("{unquoted: string)}"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("{\"array\": [D;123L,5L]}"));
|
||||
|
||||
assertEquals("NBT<nbt>", arg.toString());
|
||||
assertInvalidArg(arg, "\"unbalanced string");
|
||||
assertInvalidArg(arg, "dd}");
|
||||
assertInvalidArg(arg, "{unquoted: string)}");
|
||||
assertInvalidArg(arg, "{\"array\": [D;123L,5L]}");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentResourceLocation() {
|
||||
var arg = ArgumentType.ResourceLocation("resource_location");
|
||||
|
||||
assertEquals("minecraft:resource_location_example", arg.parse("minecraft:resource_location_example"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("minecraft:invalid resource location"));
|
||||
assertArg(arg, "minecraft:resource_location_example", arg.parse("minecraft:resource_location_example"));
|
||||
assertInvalidArg(arg, "minecraft:invalid resource location");
|
||||
|
||||
assertEquals("ResourceLocation<resource_location>", arg.toString());
|
||||
assertArg(arg, "ResourceLocation<resource_location>", arg.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentTime() {
|
||||
var arg = ArgumentType.Time("time");
|
||||
assertArg(arg, Duration.of(20, TimeUnit.SERVER_TICK), "20");
|
||||
assertArg(arg, Duration.of(40, TimeUnit.SERVER_TICK), "40t");
|
||||
assertArg(arg, Duration.of(60, TimeUnit.SECOND), "60s");
|
||||
assertArg(arg, Duration.of(80, TimeUnit.DAY), "80d");
|
||||
|
||||
assertEquals(Duration.of(20, TimeUnit.SERVER_TICK), arg.parse("20"));
|
||||
assertEquals(Duration.of(40, TimeUnit.SERVER_TICK), arg.parse("40t"));
|
||||
assertEquals(Duration.of(60, TimeUnit.SECOND), arg.parse("60s"));
|
||||
assertEquals(Duration.of(80, TimeUnit.DAY), arg.parse("80d"));
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("100x"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("2147483648t"));
|
||||
|
||||
assertEquals("Time<time>", arg.toString());
|
||||
assertInvalidArg(arg, "100x");
|
||||
assertInvalidArg(arg, "2147483648t");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentUUID() {
|
||||
var arg = ArgumentType.UUID("uuid");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("invalid_uuid"));
|
||||
assertEquals(UUID.fromString("10515090-26f2-49fa-b2ba-9594d4d0451f"), arg.parse("10515090-26f2-49fa-b2ba-9594d4d0451f"));
|
||||
|
||||
assertEquals("UUID<uuid>", arg.toString());
|
||||
assertInvalidArg(arg, "invalid_uuid");
|
||||
assertArg(arg, UUID.fromString("10515090-26f2-49fa-b2ba-9594d4d0451f"), "10515090-26f2-49fa-b2ba-9594d4d0451f");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentDouble() {
|
||||
var arg = ArgumentType.Double("double");
|
||||
|
||||
assertEquals(2564d, arg.parse("2564"));
|
||||
assertEquals(-591.981d, arg.parse("-591.981"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-5.5.52"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("++2.99"));
|
||||
|
||||
assertEquals("Double<double>", arg.toString());
|
||||
assertArg(arg, 2564d, "2564");
|
||||
assertArg(arg, -591.981d, "-591.981");
|
||||
assertInvalidArg(arg, "-5.5.52");
|
||||
assertInvalidArg(arg, "++2.99");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentFloat() {
|
||||
var arg = ArgumentType.Float("float");
|
||||
|
||||
assertEquals(2564f, arg.parse("2564"));
|
||||
assertEquals(-591.981f, arg.parse("-591.981"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-5.5.52"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("++2.99"));
|
||||
|
||||
assertEquals("Float<float>", arg.toString());
|
||||
assertArg(arg, 2564f, "2564");
|
||||
assertArg(arg, -591.981f, "-591.981");
|
||||
assertInvalidArg(arg, "-5.5.52");
|
||||
assertInvalidArg(arg, "++2.99");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentInteger() {
|
||||
var arg = ArgumentType.Integer("integer");
|
||||
|
||||
assertEquals(2564, arg.parse("2564"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("256.4"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("2147483648"));
|
||||
|
||||
assertEquals("Integer<integer>", arg.toString());
|
||||
assertArg(arg, 2564, "2564");
|
||||
assertInvalidArg(arg, "256.4");
|
||||
assertInvalidArg(arg, "2147483648");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentLong() {
|
||||
var arg = ArgumentType.Long("long");
|
||||
|
||||
assertEquals(2564, arg.parse("2564"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("256.4"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("9223372036854775808"));
|
||||
|
||||
assertEquals("Long<long>", arg.toString());
|
||||
assertArg(arg, 2564l, "2564");
|
||||
assertInvalidArg(arg, "256.4");
|
||||
assertInvalidArg(arg, "9223372036854775808");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentRelativeBlockPosition() {
|
||||
var arg = ArgumentType.RelativeBlockPosition("relative_block_position");
|
||||
|
||||
var vec = new Vec(-3, 14, 255);
|
||||
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, false), arg.parse("-3 14 +255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, false, false), arg.parse("~-3 14 +255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, true, false), arg.parse("-3 ~14 +255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, true), arg.parse("-3 14 ~+255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, true, true), arg.parse("~-3 ~14 ~+255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.LOCAL, true, true, true), arg.parse("^-3 ^14 ^+255"));
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, false), "-3 14 +255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, false, false), "~-3 14 +255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, true, false), "-3 ~14 +255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, true), "-3 14 ~+255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, true, true), "~-3 ~14 ~+255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.LOCAL, true, true, true), "^-3 ^14 ^+255");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3.50 14 +255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 14.25 +255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 14 +255.75"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 14 +-255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 text -255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 14 ~~+255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("^-3 ~14 ^+255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("^-3 14 ^+255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1 2"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1 2 3 4"));
|
||||
|
||||
assertEquals("RelativeBlockPosition<relative_block_position>", arg.toString());
|
||||
assertInvalidArg(arg, "-3.50 14 +255");
|
||||
assertInvalidArg(arg, "-3 14.25 +255");
|
||||
assertInvalidArg(arg, "-3 14 +255.75");
|
||||
assertInvalidArg(arg, "-3 14 +-255");
|
||||
assertInvalidArg(arg, "-3 text -255");
|
||||
assertInvalidArg(arg, "-3 14 ~~+255");
|
||||
assertInvalidArg(arg, "^-3 ~14 ^+255");
|
||||
assertInvalidArg(arg, "^-3 14 ^+255");
|
||||
assertInvalidArg(arg, "1 2");
|
||||
assertInvalidArg(arg, "1 2 3 4");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentRelativeVec2() {
|
||||
var arg = ArgumentType.RelativeVec2("relative_vec_2");
|
||||
|
||||
var vec = new Vec(-3, 14.25);
|
||||
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, false), arg.parse("-3 14.25"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, false, false), arg.parse("~-3 14.25"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, true), arg.parse("-3 ~14.25"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, true), arg.parse("-3 ~14.25"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, false, true), arg.parse("~-3 ~14.25"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.LOCAL, true, false, true), arg.parse("^-3 ^14.25"));
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, false), "-3 14.25");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, false, false), "~-3 14.25");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, true), "-3 ~14.25");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, true), "-3 ~14.25");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, false, true), "~-3 ~14.25");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.LOCAL, true, false, true), "^-3 ^14.25");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 +-14"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 text"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("~~-3 14"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("^-3 ~14"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("^-3 14"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1 2 3"));
|
||||
|
||||
assertEquals("RelativeVec2<relative_vec_2>", arg.toString());
|
||||
assertInvalidArg(arg, "-3 +-14");
|
||||
assertInvalidArg(arg, "-3 text");
|
||||
assertInvalidArg(arg, "~~-3 14");
|
||||
assertInvalidArg(arg, "^-3 ~14");
|
||||
assertInvalidArg(arg, "^-3 14");
|
||||
assertInvalidArg(arg, "1");
|
||||
assertInvalidArg(arg, "1 2 3");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentRelativeVec3() {
|
||||
var arg = ArgumentType.RelativeVec3("relative_vec_3");
|
||||
|
||||
var vec = new Vec(-3, 14.25, 255);
|
||||
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, false), arg.parse("-3 14.25 +255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, false, false), arg.parse("~-3 14.25 +255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, true, false), arg.parse("-3 ~14.25 +255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, true), arg.parse("-3 14.25 ~+255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, true, true), arg.parse("~-3 ~14.25 ~+255"));
|
||||
assertEquals(new RelativeVec(vec, RelativeVec.CoordinateType.LOCAL, true, true, true), arg.parse("^-3 ^14.25 ^+255"));
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, false), "-3 14.25 +255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, false, false), "~-3 14.25 +255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, true, false), "-3 ~14.25 +255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.ABSOLUTE, false, false, true), "-3 14.25 ~+255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.RELATIVE, true, true, true), "~-3 ~14.25 ~+255");
|
||||
assertArg(arg, new RelativeVec(vec, RelativeVec.CoordinateType.LOCAL, true, true, true), "^-3 ^14.25 ^+255");
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 14 +-255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 text -255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("-3 14 ~~+255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("^-3 ~14 ^+255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("^-3 14 ^+255"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1 2"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1 2 3 4"));
|
||||
|
||||
assertEquals("RelativeVec3<relative_vec_3>", arg.toString());
|
||||
assertInvalidArg(arg, "-3 14 +-255");
|
||||
assertInvalidArg(arg, "-3 text -255");
|
||||
assertInvalidArg(arg, "-3 14 ~~+255");
|
||||
assertInvalidArg(arg, "^-3 ~14 ^+255");
|
||||
assertInvalidArg(arg, "^-3 14 ^+255");
|
||||
assertInvalidArg(arg, "1 2");
|
||||
assertInvalidArg(arg, "1 2 3 4");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentBoolean() {
|
||||
var arg = ArgumentType.Boolean("boolean");
|
||||
|
||||
assertEquals(true, arg.parse("true"));
|
||||
assertNotEquals(false, arg.parse("true"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("invalid_boolean"));
|
||||
|
||||
assertEquals("Boolean<boolean>", arg.toString());
|
||||
assertArg(arg, true, "true");
|
||||
assertArg(arg, false, "false");
|
||||
assertInvalidArg(arg, "invalid_boolean");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentEnum() {
|
||||
|
||||
enum ExampleEnum { FIRST, SECOND, Third, fourth }
|
||||
enum ExampleEnum {FIRST, SECOND, Third, fourth}
|
||||
|
||||
var arg = ArgumentType.Enum("enum", ExampleEnum.class);
|
||||
|
||||
arg.setFormat(ArgumentEnum.Format.DEFAULT);
|
||||
assertEquals(ExampleEnum.FIRST, arg.parse("FIRST"));
|
||||
assertEquals(ExampleEnum.SECOND, arg.parse("SECOND"));
|
||||
assertEquals(ExampleEnum.Third, arg.parse("Third"));
|
||||
assertEquals(ExampleEnum.fourth, arg.parse("fourth"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("invalid argument"));
|
||||
assertArg(arg, ExampleEnum.FIRST, "FIRST");
|
||||
assertArg(arg, ExampleEnum.SECOND, "SECOND");
|
||||
assertArg(arg, ExampleEnum.Third, "Third");
|
||||
assertArg(arg, ExampleEnum.fourth, "fourth");
|
||||
assertInvalidArg(arg, "invalid argument");
|
||||
|
||||
arg.setFormat(ArgumentEnum.Format.UPPER_CASED);
|
||||
assertEquals(ExampleEnum.FIRST, arg.parse("FIRST"));
|
||||
assertEquals(ExampleEnum.SECOND, arg.parse("SECOND"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("Third"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("fourth"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("invalid argument"));
|
||||
assertArg(arg, ExampleEnum.FIRST, "FIRST");
|
||||
assertArg(arg, ExampleEnum.SECOND, "SECOND");
|
||||
assertInvalidArg(arg, "Third");
|
||||
assertInvalidArg(arg, "fourth");
|
||||
assertInvalidArg(arg, "invalid argument");
|
||||
|
||||
arg.setFormat(ArgumentEnum.Format.LOWER_CASED);
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("FIRST"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("SECOND"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("Third"));
|
||||
assertEquals(ExampleEnum.fourth, arg.parse("fourth"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("invalid argument"));
|
||||
|
||||
assertEquals("Enum<enum>", arg.toString());
|
||||
assertInvalidArg(arg, "FIRST");
|
||||
assertInvalidArg(arg, "SECOND");
|
||||
assertInvalidArg(arg, "Third");
|
||||
assertArg(arg, ExampleEnum.fourth, "fourth");
|
||||
assertInvalidArg(arg, "invalid argument");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentGroup() {
|
||||
var arg = ArgumentType.Group("group", ArgumentType.Integer("integer"), ArgumentType.String("string"), ArgumentType.Double("double"));
|
||||
|
||||
System.out.println(arg.parse("1234 abcd 1234.5678"));
|
||||
|
||||
// Test normal input
|
||||
var context1 = arg.parse("1234 1234 1234");
|
||||
assertEquals(1234, context1.<Integer>get("integer"));
|
||||
|
|
@ -465,25 +386,22 @@ public class ArgumentTypeTest {
|
|||
assertEquals("abcd", context2.<String>get("string"));
|
||||
assertEquals(1234.5678, context2.<Double>get("double"));
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse(""));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse(""));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse(""));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1234.5678 1234 1234.5678"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1234 1234 abcd"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1234 1234 "));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1234"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("1234 abcd 1234.5678 extra"));
|
||||
assertInvalidArg(arg, "");
|
||||
assertInvalidArg(arg, "");
|
||||
assertInvalidArg(arg, "");
|
||||
assertInvalidArg(arg, "1234.5678 1234 1234.5678");
|
||||
assertInvalidArg(arg, "1234 1234 abcd");
|
||||
assertInvalidArg(arg, "1234 1234 ");
|
||||
assertInvalidArg(arg, "1234");
|
||||
assertInvalidArg(arg, "1234 abcd 1234.5678 extra");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentLiteral() {
|
||||
var arg = ArgumentType.Literal("literal");
|
||||
|
||||
assertEquals("literal", arg.parse("literal"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("not_literal"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse(""));
|
||||
|
||||
assertEquals("Literal<literal>", arg.toString());
|
||||
assertArg(arg, "literal", arg.parse("literal"));
|
||||
assertInvalidArg(arg, "not_literal");
|
||||
assertInvalidArg(arg, "");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -492,48 +410,47 @@ public class ArgumentTypeTest {
|
|||
throw new IllegalArgumentException("This argument should never be triggered");
|
||||
}));
|
||||
|
||||
assertEquals(List.of("a", "b", "c"), arg.parse("a b c"));
|
||||
assertEquals(List.of("a", "b"), arg.parse("a b"));
|
||||
assertArg(arg, List.of("a", "b", "c"), "a b c");
|
||||
assertArg(arg, List.of("a", "b"), "a b");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentString() {
|
||||
var arg = ArgumentType.String("string");
|
||||
|
||||
assertEquals("text", arg.parse("text"));
|
||||
assertEquals("more text", arg.parse("\"more text\""));
|
||||
assertEquals("more text, but with \"escaped\" quotes", arg.parse("\"more text, but with \\\"escaped\\\" quotes\""));
|
||||
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("\"unclosed quotes"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("\"unescaped \" quotes\""));
|
||||
|
||||
assertEquals("String<string>", arg.toString());
|
||||
assertArg(arg, "text", "text");
|
||||
assertArg(arg, "more text", "\"more text\"");
|
||||
assertArg(arg, "more text, but with \"escaped\" quotes", "\"more text, but with \\\"escaped\\\" quotes\"");
|
||||
assertInvalidArg(arg, "\"unclosed quotes");
|
||||
assertInvalidArg(arg, "\"unescaped \" quotes\"");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentStringArray() {
|
||||
var arg = ArgumentType.StringArray("string_array");
|
||||
|
||||
assertArrayEquals(new String[]{"example", "text"}, arg.parse("example text"));
|
||||
assertArrayEquals(new String[]{"some", "more", "placeholder", "text"}, arg.parse("some more placeholder text"));
|
||||
assertArrayEquals(new String[]{""}, arg.parse(""));
|
||||
assertArrayEquals(new String[0], arg.parse(" "));
|
||||
assertArrayEquals(new String[0], arg.parse(" "));
|
||||
|
||||
assertEquals("StringArray<string_array>", arg.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testArgumentWord() {
|
||||
var arg = ArgumentType.Word("word").from("word1", "word2", "word3");
|
||||
|
||||
assertEquals("word1", arg.parse("word1"));
|
||||
assertEquals("word2", arg.parse("word2"));
|
||||
assertEquals("word3", arg.parse("word3"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("word"));
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse("word4"));
|
||||
assertArg(arg, "word1", "word1");
|
||||
assertArg(arg, "word2", "word2");
|
||||
assertArg(arg, "word3", "word3");
|
||||
|
||||
assertEquals("Word<word>", arg.toString());
|
||||
assertInvalidArg(arg, "word");
|
||||
assertInvalidArg(arg, "word4");
|
||||
}
|
||||
|
||||
private static <T> void assertArg(Argument<T> arg, T expected, String input) {
|
||||
assertEquals(expected, arg.parse(input));
|
||||
}
|
||||
|
||||
private static <T> void assertInvalidArg(Argument<T> arg, String input) {
|
||||
assertThrows(ArgumentSyntaxException.class, () -> arg.parse(input));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,78 +0,0 @@
|
|||
package net.minestom.server.command;
|
||||
|
||||
import net.minestom.server.command.builder.Command;
|
||||
import net.minestom.server.command.builder.CommandDispatcher;
|
||||
import net.minestom.server.command.builder.arguments.ArgumentType;
|
||||
import net.minestom.server.permission.Permission;
|
||||
import net.minestom.server.tag.TagHandler;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
|
||||
public class CommandParsingTest {
|
||||
|
||||
@Test
|
||||
public void findCommand() {
|
||||
var dispatcher = new CommandDispatcher();
|
||||
assertNull(dispatcher.findCommand("name"));
|
||||
var command1 = new Command("name");
|
||||
dispatcher.register(command1);
|
||||
assertEquals(command1, dispatcher.findCommand("name"));
|
||||
dispatcher.unregister(command1);
|
||||
assertNull(dispatcher.findCommand("name"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseDefault() {
|
||||
var dispatcher = new CommandDispatcher();
|
||||
var sender = new Sender();
|
||||
AtomicReference<String> data = new AtomicReference<>();
|
||||
var command = new Command("name");
|
||||
command.setDefaultExecutor((s, context) -> data.set("default"));
|
||||
dispatcher.register(command);
|
||||
|
||||
dispatcher.execute(sender, "name");
|
||||
assertEquals("default", data.get());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseLiteral() {
|
||||
var dispatcher = new CommandDispatcher();
|
||||
var sender = new Sender();
|
||||
AtomicReference<String> data = new AtomicReference<>();
|
||||
var command = new Command("name");
|
||||
command.setDefaultExecutor((s, context) -> data.set("default"));
|
||||
command.addSyntax((s, context) -> data.set("literal"),
|
||||
ArgumentType.Literal("literal"));
|
||||
dispatcher.register(command);
|
||||
|
||||
dispatcher.execute(sender, "name");
|
||||
assertEquals("default", data.get());
|
||||
|
||||
data.set(null);
|
||||
dispatcher.execute(sender, "name literal");
|
||||
assertEquals("literal", data.get());
|
||||
|
||||
// Do not ignore cases
|
||||
data.set(null);
|
||||
dispatcher.execute(sender, "name Literal");
|
||||
assertEquals("default", data.get());
|
||||
}
|
||||
|
||||
private static final class Sender implements CommandSender {
|
||||
@Override
|
||||
public @NotNull Set<Permission> getAllPermissions() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NotNull TagHandler tagHandler() {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -51,5 +51,4 @@ public class CommandTest {
|
|||
assertTrue(checkSet.get());
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user