/**
* PermissionsEx
* Copyright (C) zml and PermissionsEx contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package ninja.leaping.permissionsex.util.command;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import ninja.leaping.permissionsex.util.command.args.ArgumentParseException;
import ninja.leaping.permissionsex.util.command.args.CommandArgs;
import ninja.leaping.permissionsex.util.command.args.CommandElement;
import ninja.leaping.permissionsex.util.command.args.QuotedStringParser;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static ninja.leaping.permissionsex.util.command.args.GenericArguments.*;
import static ninja.leaping.permissionsex.util.Translations.untr;
import static org.junit.Assert.*;
/**
* Tests for all argument types contained in GenericArguments
*/
public class GenericArgumentsTest {
static final CommandExecutor NULL_EXECUTOR = new CommandExecutor() {
@Override
public <TextType> void execute(Commander<TextType> src, CommandContext args) throws CommandException {
}
};
@Rule
public ExpectedException expected = ExpectedException.none();
private static CommandContext parseForInput(String input, CommandElement element) throws ArgumentParseException {
CommandSpec spec = CommandSpec.builder()
.setAliases("test")
.setExecutor(NULL_EXECUTOR)
.build();
CommandArgs args = QuotedStringParser.parseFrom(input, false);
CommandContext context = new CommandContext(spec, args.getRaw());
element.parse(args, context);
return context;
}
@Test
public void testNone() throws ArgumentParseException {
CommandArgs args = QuotedStringParser.parseFrom("a", false);
CommandContext context = new CommandContext(CommandSpec.builder().setAliases("test").setExecutor(NULL_EXECUTOR).build(), args.getRaw());
none().parse(args, context);
assertEquals("a", args.next());
}
@Test
@Ignore
public void testFlags() {
throw new UnsupportedOperationException();
}
@Test
public void testSequence() throws ArgumentParseException {
CommandElement el = seq(string(untr("one")), string(untr("two")), string(untr("three")));
CommandContext context = parseForInput("a b c", el);
assertEquals("a", context.getOne("one"));
assertEquals("b", context.getOne("two"));
assertEquals("c", context.getOne("three"));
expected.expect(ArgumentParseException.class);
parseForInput("a b", el);
}
@Test
public void testChoices() throws ArgumentParseException {
CommandElement el = choices(untr("val"), ImmutableMap.of("a", "one", "b", "two"));
CommandContext context = parseForInput("a", el);
assertEquals("one", context.getOne("val"));
expected.expect(ArgumentParseException.class);
parseForInput("c", el);
}
@Test
public void testFirstParsing() throws ArgumentParseException {
CommandElement el = firstParsing(integer(untr("val")), string(untr("val")));
CommandContext context = parseForInput("word", el);
assertEquals("word", context.getOne("val"));
context = parseForInput("42", el);
assertEquals((Integer) 42, context.getOne("val"));
}
@Test
public void testOptional() throws ArgumentParseException {
CommandElement el = optional(string(untr("val")));
CommandContext context = parseForInput("", el);
assertNull(context.getOne("val"));
el = optional(string(untr("val")), "def");
context = parseForInput("", el);
assertEquals("def", context.getOne("val"));
el = seq(optionalWeak(integer(untr("val"))), string(untr("str")));
context = parseForInput("hello", el);
assertEquals("hello", context.getOne("str"));
el = seq(optional(integer(untr("val")), string(untr("str"))));
expected.expect(ArgumentParseException.class);
parseForInput("hello", el);
}
@Test
public void testRepeated() throws ArgumentParseException {
CommandContext context = parseForInput("1 1 2 3 5", repeated(integer(untr("key")), 5));
assertEquals(ImmutableList.<Object>of(1, 1, 2, 3, 5), context.getAll("key"));
}
@Test
public void testAllOf() throws ArgumentParseException {
CommandContext context = parseForInput("2 4 8 16 32 64 128", allOf(integer(untr("key"))));
assertEquals(ImmutableList.<Object>of(2, 4, 8, 16, 32, 64, 128), context.getAll("key"));
}
@Test
public void testString() throws ArgumentParseException {
CommandContext context = parseForInput("\"here it is\"", string(untr("a value")));
assertEquals("here it is", context.getOne("a value"));
}
@Test
public void testInteger() throws ArgumentParseException {
CommandContext context = parseForInput("52", integer(untr("a value")));
assertEquals((Integer) 52, context.getOne("a value"));
expected.expect(ArgumentParseException.class);
parseForInput("notanumber", integer(untr("a value")));
}
@Test
public void testBool() throws ArgumentParseException {
CommandElement boolEl = bool(untr("val"));
assertEquals(true, parseForInput("true", boolEl).getOne("val"));
assertEquals(true, parseForInput("t", boolEl).getOne("val"));
assertEquals(false, parseForInput("f", boolEl).getOne("val"));
expected.expect(ArgumentParseException.class);
parseForInput("notabool", boolEl);
}
private enum TestEnum {
ONE, TWO, RED
}
@Test
public void testEnumValue() throws ArgumentParseException {
CommandElement enumEl = enumValue(untr("val"), TestEnum.class);
assertEquals(TestEnum.ONE, parseForInput("one", enumEl).getOne("val"));
assertEquals(TestEnum.TWO, parseForInput("TwO", enumEl).getOne("val"));
assertEquals(TestEnum.RED, parseForInput("RED", enumEl).getOne("val"));
expected.expect(ArgumentParseException.class);
parseForInput("notanel", enumEl);
}
@Test
public void testRemainingJoinedStrings() throws ArgumentParseException {
CommandElement remainingJoined = remainingJoinedStrings(untr("val"));
assertEquals("one", parseForInput("one", remainingJoined).getOne("val"));
assertEquals("one big string", parseForInput("one big string", remainingJoined).getOne("val"));
}
}