Remove some unused code.

Author: Aleksi Salmela

src/main/java/fi/helsinki/cs/tmc/cli/core/CommandFactory.java

@@ -42,25 +42,6 @@ public static void addCommand(String name, String packageName, Class commandClas
         list.add(klass);
     }
 
-    /**
-     * Merge this method implementation with the above version.
-     *
-     * @param packageName The package/category of the command
-     * @param commandClass The class of the command
-     */
-    protected static void addCommand(String packageName, Class commandClass) {
-        Class<Command> klass = castToCommandClass(commandClass);
-        Annotation annotation = klass.getAnnotation(Command.class);
-        if (annotation == null) {
-            throw new RuntimeException("Command must have Command annotation");
-        }
-        Command command = (Command) annotation;
-        if (!AbstractCommand.class.isAssignableFrom(commandClass)) {
-            throw new RuntimeException("Command must implement CommandInterface");
-        }
-        CommandFactory.addCommand(command.name(), packageName, commandClass);
-    }
-
     /**
      * Create new instance of the command.
      *

src/test/java/fi/helsinki/cs/tmc/cli/core/CommandFactoryTest.java

@@ -29,27 +29,6 @@ public class CommandFactoryTest {
 
     private CliContext ctx;
 
-    @Before
-    public void setUp() {
-        ctx = new CliContext(new TestIo());
-        CommandFactory.reload();
-    }
-
-    @Test
-    public void constructorAddsCommands() {
-        assertTrue(!CommandFactory.getCommands().isEmpty());
-    }
-
-    @Test
-    public void createHelpCommand() {
-        assertNotNull(CommandFactory.createCommand("help"));
-    }
-
-    @Test
-    public void createNonexistingCommand() {
-        assertNull(CommandFactory.createCommand("foobar"));
-    }
-
     @Command(name = "good", desc = "test")
     public static class GoodCommand extends AbstractCommand {
 
@@ -64,42 +43,25 @@ public void run(CliContext context, CommandLine args) {
         }
     }
 
-    @Test
-    public void addGoodCommand() {
-        CommandFactory.addCommand("category", GoodCommand.class);
-        //TODO check the all the stuff in the command
-        assertNotNull(CommandFactory.createCommand("good"));
+    @Before
+    public void setUp() {
+        ctx = new CliContext(new TestIo());
+        CommandFactory.reload();
     }
 
-    public static class BadCommand extends AbstractCommand {
-
-        @Override
-        public void getOptions(Options options) {
-            throw new UnsupportedOperationException();
-        }
-
-        @Override
-        public void run(CliContext context, CommandLine args) {
-            throw new UnsupportedOperationException();
-        }
+    @Test
+    public void constructorAddsCommands() {
+        assertTrue(!CommandFactory.getCommands().isEmpty());
     }
 
-    @Test(expected = RuntimeException.class)
-    public void addCommandWithoutProperAnnotation() {
-        //WARNING The exception code leads to unpredicatble test results
-        //exception.expect(RuntimeException.class);
-        //exception.expectMessage(contains("annotation"));
-        CommandFactory.addCommand("category", BadCommand.class);
+    @Test
+    public void createHelpCommand() {
+        assertNotNull(CommandFactory.createCommand("help"));
     }
 
-    private static class ReallyBadCommand {}
-
-    @Test(expected = RuntimeException.class)
-    public void addCommandThatDoesntExtendInterface() {
-        //WARNING The exception code leads to unpredicatble test results
-        //exception.expect(RuntimeException.class);
-        //exception.expectMessage(contains("Interface"));
-        CommandFactory.addCommand("category", ReallyBadCommand.class);
+    @Test
+    public void createNonexistingCommand() {
+        assertNull(CommandFactory.createCommand("foobar"));
     }
 
     @Test
@@ -112,7 +74,7 @@ public void getCommandsGivesDefaultCommands() {
     @Test
     public void getCommandsWhenSingleCommandIsAdded() {
         int oldSize = CommandFactory.getCommands().size();
-        CommandFactory.addCommand("", GoodCommand.class);
+        CommandFactory.addCommand("good", "", GoodCommand.class);
         assertEquals(oldSize + 1, CommandFactory.getCommands().size());
         assertTrue(CommandFactory.getCommands().contains(
                 CommandFactory.castToCommandClass(GoodCommand.class)));
@@ -126,7 +88,7 @@ public void getCategoryCommandsWhenItsEmpty() {
     @Test
     public void getCategoryCommandsWhenSingleCategorizedCommandIsAdded() {
         int oldSize = CommandFactory.getCommands().size();
-        CommandFactory.addCommand("xyz", GoodCommand.class);
+        CommandFactory.addCommand("good", "xyz", GoodCommand.class);
         List<Class<Command>> list = CommandFactory.getCategoryCommands("xyz");
         assertEquals(1, list.size());
         assertEquals(GoodCommand.class, list.get(0));