Add AutoCommandType.

Remove existing auto commands dialog model.

src/com/dmdirc/commandparser/auto/AutoCommand.java

@@ -44,6 +44,8 @@ public class AutoCommand {
     private final Optional<String> profile;
     /** The commands to execute. */
     private final String response;
+    /** The type of auto command. */
+    private final AutoCommandType type;
 
     public AutoCommand(
             final Optional<String> server,
@@ -54,6 +56,15 @@ public class AutoCommand {
         this.network = network;
         this.profile = profile;
         this.response = response;
+        if (!server.isPresent() && !network.isPresent()) {
+            type = AutoCommandType.GLOBAL;
+        } else if (server.isPresent() && !network.isPresent()) {
+            type = AutoCommandType.SERVER;
+        } else if (!server.isPresent()) {
+            type = AutoCommandType.NETWORK;
+        } else {
+            type = AutoCommandType.UNKNOWN;
+        }
     }
 
     public Optional<String> getServer() {
@@ -73,6 +84,10 @@ public class AutoCommand {
         return response;
     }
 
+    public AutoCommandType getType() {
+        return type;
+    }
+
     @Override
     public boolean equals(final Object object) {
         if (object == null) {

src/com/dmdirc/commandparser/auto/AutoCommandHandler.java

@@ -85,16 +85,16 @@ public class AutoCommandHandler {
     private boolean appliesToServer(final String network, final String server,
             final String profile) {
         return !isGlobalCommand()
-                && matchesIfPreset(autoCommand.getNetwork(), network)
-                && matchesIfPreset(autoCommand.getServer(), server)
-                && matchesIfPreset(autoCommand.getProfile(), profile);
+                && matchesIfPresent(autoCommand.getNetwork(), network)
+                && matchesIfPresent(autoCommand.getServer(), server)
+                && matchesIfPresent(autoCommand.getProfile(), profile);
     }
 
     private boolean isGlobalCommand() {
         return !autoCommand.getServer().isPresent() && !autoCommand.getNetwork().isPresent();
     }
 
-    private boolean matchesIfPreset(final Optional<String> target, final String value) {
+    private boolean matchesIfPresent(final Optional<String> target, final String value) {
         return !target.isPresent() || target.get().equalsIgnoreCase(value);
     }
 

src/com/dmdirc/commandparser/auto/AutoCommandManager.java

@@ -23,7 +23,7 @@
 package com.dmdirc.commandparser.auto;
 
 import com.dmdirc.DMDircMBassador;
-import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.config.profiles.Profile;
 
 import java.util.Collections;
 import java.util.Map;
@@ -166,13 +166,12 @@ public class AutoCommandManager {
      *
      * @return The set of all known connection auto commands.
      */
-    public Set<AutoCommand> getConnectionAutoCommands(final String server,
-            final ConfigProvider profile) {
+    public Set<AutoCommand> getConnectionAutoCommands(final String server, final Profile profile) {
         return getAutoCommands().parallelStream()
                 .filter(c -> c.getServer().isPresent() &&
                         c.getServer().get().equalsIgnoreCase(server))
-                .filter(c -> c.getProfile().isPresent() && c.getProfile().get().equalsIgnoreCase(
-                        profile.getName()))
+                .filter(c -> c.getProfile().isPresent()
+                        && c.getProfile().get().equalsIgnoreCase(profile.getName()))
                 .collect(Collectors.toSet());
     }
 
@@ -199,13 +198,12 @@ public class AutoCommandManager {
      *
      * @return The set of all known connection auto commands.
      */
-    public Set<AutoCommand> getNetworkAutoCommands(final String network,
-            final ConfigProvider profile) {
+    public Set<AutoCommand> getNetworkAutoCommands(final String network, final Profile profile) {
         return getAutoCommands().parallelStream()
                 .filter(c -> c.getNetwork().isPresent() &&
                         c.getNetwork().get().equalsIgnoreCase(network))
-                .filter(c -> c.getProfile().isPresent() && c.getProfile().get().equalsIgnoreCase
-                        (profile.getName()))
+                .filter(c -> c.getProfile().isPresent()
+                        && c.getProfile().get().equalsIgnoreCase(profile.getName()))
                 .collect(Collectors.toSet());
     }
 

src/com/dmdirc/ui/core/autocommands/AutoCommandType.java → src/com/dmdirc/commandparser/auto/AutoCommandType.java

@@ -20,10 +20,14 @@
  * SOFTWARE.
  */
 
-package com.dmdirc.ui.core.autocommands;
+package com.dmdirc.commandparser.auto;
 
+/**
+ * Specifies the type of auto command.
+ */
 public enum AutoCommandType {
+    SERVER,
+    NETWORK,
     GLOBAL,
-    CONNECTION,
-    ALL
+    UNKNOWN
 }

src/com/dmdirc/interfaces/ui/AutoCommandsModel.java

@@ -22,7 +22,7 @@
 
 package com.dmdirc.interfaces.ui;
 
-import com.dmdirc.ui.core.autocommands.AutoCommandType;
+import com.dmdirc.commandparser.auto.AutoCommandType;
 import com.dmdirc.ui.core.autocommands.MutableAutoCommand;
 
 import java.util.Collection;

src/com/dmdirc/ui/core/autocommands/CoreAutoCommandsModel.java

@@ -1,239 +0,0 @@
-/*
- * Copyright (c) 2006-2014 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.ui.core.autocommands;
-
-import com.dmdirc.commandparser.auto.AutoCommand;
-import com.dmdirc.commandparser.auto.AutoCommandManager;
-import com.dmdirc.interfaces.ui.AutoCommandsModel;
-import com.dmdirc.interfaces.ui.AutoCommandsModelListener;
-import com.dmdirc.util.collections.ListenerList;
-
-import com.google.common.collect.Sets;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Optional;
-import java.util.Set;
-
-import javax.annotation.Nonnull;
-import javax.inject.Inject;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-
-public class CoreAutoCommandsModel implements AutoCommandsModel {
-
-    private final AutoCommandManager manager;
-    private final Set<AutoCommand> originalCommands;
-    private final Set<MutableAutoCommand> commands;
-    private AutoCommandType type;
-    private boolean loaded;
-    private Optional<MutableAutoCommand> selectedCommand;
-    private ListenerList listeners;
-
-    @Inject
-    public CoreAutoCommandsModel(final AutoCommandManager manager) {
-        this.manager = manager;
-        originalCommands = Sets.newHashSet();
-        commands = Sets.newHashSet();
-    }
-
-    @Override
-    public void addListener(@Nonnull final AutoCommandsModelListener listener) {
-        checkNotNull(listener);
-        listeners.add(AutoCommandsModelListener.class, listener);
-    }
-
-    @Override
-    public void removeListener(@Nonnull final AutoCommandsModelListener listener) {
-        checkNotNull(listener);
-        listeners.remove(AutoCommandsModelListener.class, listener);
-    }
-
-    @Override
-    public void setType(@Nonnull final AutoCommandType type) {
-        checkNotNull(type);
-        checkState(this.type == null);
-        this.type = type;
-    }
-
-    @Override
-    public void loadModel() {
-        checkNotNull(type);
-        checkState(!loaded);
-        loaded = true;
-        listeners = new ListenerList();
-        originalCommands.clear();
-        commands.clear();
-        selectedCommand = Optional.empty();
-        switch(type) {
-            case ALL:
-                manager.getAutoCommands().stream().map(c -> {
-                    originalCommands.add(c);
-                    return new MutableAutoCommand(c);
-                }).forEach(commands::add);
-                break;
-            case CONNECTION:
-                manager.getConnectionAutoCommands().stream().map(c -> {
-                    originalCommands.add(c);
-                    return new MutableAutoCommand(c);
-                }).forEach(commands::add);
-                break;
-            case GLOBAL:
-                manager.getGlobalAutoCommands().stream().map(c -> {
-                    originalCommands.add(c);
-                    return new MutableAutoCommand(c);
-                }).forEach(commands::add);
-                break;
-        }
-    }
-
-    @Override
-    @Nonnull
-    public Collection<MutableAutoCommand> getAutoCommands() {
-        return Collections.unmodifiableCollection(commands);
-    }
-
-    @Override
-    public void setAutoCommands(@Nonnull final Collection<MutableAutoCommand> commands) {
-        checkNotNull(commands);
-        this.commands.clear();
-        this.commands.addAll(commands);
-        listeners.getCallable(AutoCommandsModelListener.class).setAutoCommands(this.commands);
-    }
-
-    @Override
-    @Nonnull
-    public Optional<MutableAutoCommand> getSelectedCommand() {
-        return selectedCommand;
-    }
-
-    @Override
-    public void setSelectedCommand(@Nonnull final Optional<MutableAutoCommand> selectedCommand) {
-        checkNotNull(selectedCommand);
-        selectedCommand.ifPresent(s -> checkArgument(commands.contains(s)));
-        if (!this.selectedCommand.equals(selectedCommand)) {
-            this.selectedCommand = selectedCommand;
-            listeners.getCallable(AutoCommandsModelListener.class)
-                    .selectedCommandChanged(selectedCommand);
-        }
-    }
-
-    @Override
-    @Nonnull
-    public Optional<String> getSelectedCommandServer() {
-        if (selectedCommand.isPresent()) {
-            return selectedCommand.get().getServer();
-        }
-        return Optional.empty();
-    }
-
-    @Override
-    @Nonnull
-    public Optional<String> getSelectedCommandNetwork() {
-        if (selectedCommand.isPresent()) {
-            return selectedCommand.get().getNetwork();
-        }
-        return Optional.empty();
-    }
-
-    @Override
-    @Nonnull
-    public Optional<String> getSelectedCommandProfile() {
-        if (selectedCommand.isPresent()) {
-            return selectedCommand.get().getProfile();
-        }
-        return Optional.empty();
-    }
-
-    @Override
-    @Nonnull
-    public String getSelectedCommandResponse() {
-        if (selectedCommand.isPresent()) {
-            return selectedCommand.get().getResponse();
-        }
-        return "";
-    }
-
-    @Override
-    public void setSelectedCommandServer(@Nonnull final Optional<String> server) {
-        checkNotNull(server);
-        selectedCommand.ifPresent(s -> {
-            s.setServer(server);
-            listeners.getCallable(AutoCommandsModelListener.class)
-                    .commandEdited(selectedCommand.get());
-        });
-    }
-
-    @Override
-    public void setSelectedCommandNetwork(@Nonnull final Optional<String> network) {
-        checkNotNull(network);
-        selectedCommand.ifPresent(s -> {
-            s.setNetwork(network);
-            listeners.getCallable(AutoCommandsModelListener.class)
-                    .commandEdited(selectedCommand.get());
-        });
-    }
-
-    @Override
-    public void setSelectedCommandProfile(@Nonnull final Optional<String> profile) {
-        checkNotNull(profile);
-        selectedCommand.ifPresent(s -> {
-            s.setProfile(profile);
-            listeners.getCallable(AutoCommandsModelListener.class)
-                    .commandEdited(selectedCommand.get());});
-    }
-
-    @Override
-    public void setSelectedCommandResponse(@Nonnull final String response) {
-        checkNotNull(response);
-        checkArgument(!response.isEmpty());
-        selectedCommand.ifPresent(s -> {
-            s.setResponse(response);
-            listeners.getCallable(AutoCommandsModelListener.class)
-                    .commandEdited(selectedCommand.get());});
-    }
-
-    @Override
-    public void addCommand(@Nonnull final MutableAutoCommand command) {
-        checkNotNull(command);
-        checkArgument(!commands.contains(command));
-        commands.add(command);
-        listeners.getCallable(AutoCommandsModelListener.class).commandAdded(command);
-    }
-
-    @Override
-    public void removeCommand(@Nonnull final MutableAutoCommand command) {
-        checkNotNull(command);
-        checkArgument(commands.contains(command));
-        commands.remove(command);
-        listeners.getCallable(AutoCommandsModelListener.class).commandRemoved(command);
-    }
-
-    @Override
-    public void save() {
-        originalCommands.forEach(manager::removeAutoCommand);
-        commands.stream().map(MutableAutoCommand::getAutoCommand).forEach(manager::addAutoCommand);
-    }
-}

src/com/dmdirc/ui/core/autocommands/MutableAutoCommand.java

@@ -23,7 +23,6 @@
 package com.dmdirc.ui.core.autocommands;
 
 import com.dmdirc.commandparser.auto.AutoCommand;
-import com.dmdirc.ui.core.profiles.MutableProfile;
 
 import com.google.common.base.MoreObjects;
 

test/com/dmdirc/commandparser/auto/AutoCommandManagerTest.java

@@ -23,7 +23,7 @@
 package com.dmdirc.commandparser.auto;
 
 import com.dmdirc.DMDircMBassador;
-import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.config.profiles.Profile;
 
 import java.util.Optional;
 
@@ -49,7 +49,7 @@ public class AutoCommandManagerTest {
     @Mock private AutoCommandHandler ircquakenetHandler;
     @Mock private AutoCommandHandler ukquakenetHandler;
     @Mock private AutoCommandHandler testnetHandler;
-    @Mock private ConfigProvider testProfile;
+    @Mock private Profile testProfile;
     private AutoCommandManager autoCommandManager;
     private AutoCommand global;
     private AutoCommand ircquakenet;

test/com/dmdirc/commandparser/auto/AutoCommandTest.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2006-2014 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.commandparser.auto;
+
+import java.util.Optional;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class AutoCommandTest {
+
+    private AutoCommand command;
+
+    @Before
+    public void setUp() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.empty(), Optional.empty(), "");
+    }
+
+    @Test
+    public void testGetServer_Empty() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.empty(), Optional.empty(), "");
+        assertEquals(Optional.<String>empty(), command.getServer());
+    }
+
+    @Test
+    public void testGetServer_NotEmpty() throws Exception {
+        command = new AutoCommand(Optional.of("server"), Optional.empty(), Optional.empty(), "");
+        assertEquals(Optional.of("server"), command.getServer());
+    }
+
+    @Test
+    public void testGetNetwork_Empty() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.empty(), Optional.empty(), "");
+        assertEquals(Optional.<String>empty(), command.getNetwork());
+    }
+
+    @Test
+    public void testGetNetwork_NotEmpty() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.of("network"), Optional.empty(), "");
+        assertEquals(Optional.of("network"), command.getNetwork());
+    }
+
+    @Test
+    public void testGetProfile_Empty() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.empty(), Optional.empty(), "");
+        assertEquals(Optional.<String>empty(), command.getProfile());
+    }
+
+    @Test
+    public void testGetProfile_NotEmpty() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.empty(), Optional.of("profile"), "");
+        assertEquals(Optional.of("profile"), command.getProfile());
+    }
+
+    @Test
+    public void testGetResponse_Empty() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.empty(), Optional.empty(), "");
+        assertEquals("", command.getResponse());
+    }
+
+    @Test
+    public void testGetResponse_NotEmpty() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.empty(), Optional.empty(), "response");
+        assertEquals("response", command.getResponse());
+    }
+
+    @Test
+    public void testGetType_Server() throws Exception {
+        command = new AutoCommand(Optional.of("server"), Optional.empty(), Optional.empty(),
+                "response");
+        assertEquals(AutoCommandType.SERVER, command.getType());
+    }
+
+    @Test
+    public void testGetType_Network() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.of("network"), Optional.empty(),
+                "response");
+        assertEquals(AutoCommandType.NETWORK, command.getType());
+    }
+
+    @Test
+    public void testGetType_Global() throws Exception {
+        command = new AutoCommand(Optional.empty(), Optional.empty(), Optional.of("profile"),
+                "response");
+        assertEquals(AutoCommandType.GLOBAL, command.getType());
+    }
+
+    @Test
+    public void testGetType_Unknown() throws Exception {
+        command = new AutoCommand(Optional.of("server"), Optional.of("network"), Optional.empty(),
+                "response");
+        assertEquals(AutoCommandType.UNKNOWN, command.getType());
+    }
+}

test/com/dmdirc/ui/core/autocommands/CoreAutoCommandsModelTest.java

@@ -1,359 +0,0 @@
-/*
- * Copyright (c) 2006-2014 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.ui.core.autocommands;
-
-import com.dmdirc.commandparser.auto.AutoCommand;
-import com.dmdirc.commandparser.auto.AutoCommandManager;
-import com.dmdirc.interfaces.ui.AutoCommandsModel;
-import com.dmdirc.interfaces.ui.AutoCommandsModelListener;
-
-import com.google.common.collect.Sets;
-
-import java.util.Optional;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-
-import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertFalse;
-import static junit.framework.TestCase.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class CoreAutoCommandsModelTest {
-
-    @Mock private AutoCommandManager manager;
-    @Mock private AutoCommandsModelListener listener;
-    private AutoCommandsModel instance;
-    private MutableAutoCommand mutableCommand1;
-    private MutableAutoCommand mutableCommand2;
-    private MutableAutoCommand mutableCommand3;
-    private MutableAutoCommand mutableCommand4;
-    private MutableAutoCommand mutableCommand5;
-
-    @Before
-    public void setUp() throws Exception {
-        final AutoCommand command1 = new AutoCommand(Optional.of("server1"),
-                Optional.of("network1"), Optional.of("profile1"), "response1");
-        final AutoCommand command2 = new AutoCommand(Optional.empty(),
-                Optional.empty(), Optional.of("profile2"), "response2");
-        final AutoCommand command3 = new AutoCommand(Optional.of("server3"),
-                Optional.of("network3"), Optional.of("profile3"), "response3");
-        final AutoCommand command4 = new AutoCommand(Optional.empty(),
-                Optional.empty(), Optional.of("profile4"), "response4");
-        final AutoCommand command5 = new AutoCommand(Optional.empty(),
-                Optional.empty(), Optional.of("profile5"), "response5");
-        mutableCommand1 = new MutableAutoCommand(command1);
-        mutableCommand2 = new MutableAutoCommand(command2);
-        mutableCommand3 = new MutableAutoCommand(command3);
-        mutableCommand4 = new MutableAutoCommand(command4);
-        mutableCommand5 = new MutableAutoCommand(command5);
-        when(manager.getAutoCommands())
-                .thenReturn(Sets.newHashSet(command1, command2, command3, command4));
-        when(manager.getConnectionAutoCommands()).thenReturn(Sets.newHashSet(command1, command3));
-        when(manager.getGlobalAutoCommands()).thenReturn(Sets.newHashSet(command2, command4));
-        instance = new CoreAutoCommandsModel(manager);
-        instance.setType(AutoCommandType.ALL);
-        instance.loadModel();
-        instance.addListener(listener);
-    }
-
-    @Test
-    public void testAddListener() throws Exception {
-        instance = new CoreAutoCommandsModel(manager);
-        instance.setType(AutoCommandType.ALL);
-        instance.loadModel();
-        instance.setSelectedCommand(Optional.of(mutableCommand2));
-        verify(listener, never()).selectedCommandChanged(Optional.of(mutableCommand2));
-        instance.addListener(listener);
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        verify(listener).selectedCommandChanged(Optional.of(mutableCommand1));
-    }
-
-    @Test
-    public void testRemoveListener() throws Exception {
-        instance = new CoreAutoCommandsModel(manager);
-        instance.setType(AutoCommandType.ALL);
-        instance.loadModel();
-        instance.setSelectedCommand(Optional.of(mutableCommand2));
-        verify(listener, never()).selectedCommandChanged(Optional.of(mutableCommand2));
-        instance.addListener(listener);
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        verify(listener).selectedCommandChanged(Optional.of(mutableCommand1));
-        instance.removeListener(listener);
-        instance.setSelectedCommand(Optional.of(mutableCommand2));
-        verify(listener, never()).selectedCommandChanged(Optional.of(mutableCommand2));
-    }
-
-    @Test
-    public void testLoadModel_All() throws Exception {
-        instance = new CoreAutoCommandsModel(manager);
-        instance.setType(AutoCommandType.ALL);
-        assertTrue(instance.getAutoCommands().isEmpty());
-        instance.loadModel();
-        assertFalse(instance.getAutoCommands().isEmpty());
-        assertEquals(4, instance.getAutoCommands().size());
-        assertTrue(instance.getAutoCommands().contains(mutableCommand1));
-        assertTrue(instance.getAutoCommands().contains(mutableCommand2));
-        assertTrue(instance.getAutoCommands().contains(mutableCommand3));
-        assertTrue(instance.getAutoCommands().contains(mutableCommand4));
-    }
-
-    @Test
-    public void testLoadModel_Global() throws Exception {
-        instance = new CoreAutoCommandsModel(manager);
-        instance.setType(AutoCommandType.GLOBAL);
-        assertTrue(instance.getAutoCommands().isEmpty());
-        instance.loadModel();
-        assertFalse(instance.getAutoCommands().isEmpty());
-        assertEquals(2, instance.getAutoCommands().size());
-        assertFalse(instance.getAutoCommands().contains(mutableCommand1));
-        assertTrue(instance.getAutoCommands().contains(mutableCommand2));
-        assertFalse(instance.getAutoCommands().contains(mutableCommand3));
-        assertTrue(instance.getAutoCommands().contains(mutableCommand4));
-    }
-
-    @Test
-    public void testLoadModel_Connection() throws Exception {
-        instance = new CoreAutoCommandsModel(manager);
-        instance.setType(AutoCommandType.CONNECTION);
-        assertTrue(instance.getAutoCommands().isEmpty());
-        instance.loadModel();
-        assertFalse(instance.getAutoCommands().isEmpty());
-        assertEquals(2, instance.getAutoCommands().size());
-        assertTrue(instance.getAutoCommands().contains(mutableCommand1));
-        assertFalse(instance.getAutoCommands().contains(mutableCommand2));
-        assertTrue(instance.getAutoCommands().contains(mutableCommand3));
-        assertFalse(instance.getAutoCommands().contains(mutableCommand4));
-    }
-
-    @Test
-    public void testSetAutoCommands_Empty() throws Exception {
-        assertFalse(instance.getAutoCommands().isEmpty());
-        instance.setAutoCommands(Sets.newHashSet());
-        assertTrue(instance.getAutoCommands().isEmpty());
-        verify(listener).setAutoCommands(Sets.newHashSet());
-    }
-
-    @Test
-    public void testSetAutoCommands_NotEmpty() throws Exception {
-        assertEquals(4, instance.getAutoCommands().size());
-        instance.setAutoCommands(Sets.newHashSet(mutableCommand1, mutableCommand2));
-        assertEquals(2, instance.getAutoCommands().size());
-        verify(listener).setAutoCommands(Sets.newHashSet(mutableCommand1, mutableCommand2));
-    }
-
-    @Test
-    public void testGetSelectedCommand() throws Exception {
-        assertEquals(Optional.<MutableAutoCommand>empty(), instance.getSelectedCommand());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        assertEquals(Optional.of(mutableCommand1), instance.getSelectedCommand());
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testSetSelectedCommand_UnknownCommand() {
-        assertEquals(Optional.<MutableAutoCommand>empty(), instance.getSelectedCommand());
-        instance.setSelectedCommand(Optional.of(mutableCommand5));
-        verify(listener, never()).selectedCommandChanged(any());
-    }
-
-    @Test
-    public void testSetSelectedCommand_EmptyCommand() {
-        assertEquals(Optional.<MutableAutoCommand>empty(), instance.getSelectedCommand());
-        instance.setSelectedCommand(Optional.of(mutableCommand4));
-        assertEquals(Optional.of(mutableCommand4), instance.getSelectedCommand());
-        instance.setSelectedCommand(Optional.empty());
-        assertEquals(Optional.<MutableAutoCommand>empty(), instance.getSelectedCommand());
-        verify(listener).selectedCommandChanged(Optional.empty());
-    }
-
-    @Test
-    public void testGetSelectedCommandServer() throws Exception {
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandServer());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        assertEquals(mutableCommand1.getServer(), instance.getSelectedCommandServer());
-    }
-
-    @Test
-    public void testGetSelectedCommandNetwork() throws Exception {
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandNetwork());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        assertEquals(mutableCommand1.getNetwork(), instance.getSelectedCommandNetwork());
-    }
-
-    @Test
-    public void testGetSelectedCommandProfile() throws Exception {
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandProfile());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        assertEquals(mutableCommand1.getProfile(), instance.getSelectedCommandProfile());
-    }
-
-    @Test
-    public void testGetSelectedCommandResponse() throws Exception {
-        assertEquals("", instance.getSelectedCommandResponse());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        assertEquals(mutableCommand1.getResponse(), instance.getSelectedCommandResponse());
-    }
-
-    @Test
-    public void testSetSelectedCommandServer_Empty() throws Exception {
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandServer());
-        instance.setSelectedCommandServer(Optional.of("server"));
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandServer());
-        verify(listener, never()).commandEdited(any());
-    }
-
-    @Test
-    public void testSetSelectedCommandServer() throws Exception {
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandServer());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        instance.setSelectedCommandServer(Optional.of("server"));
-        assertEquals(Optional.of("server"), instance.getSelectedCommandServer());
-        verify(listener).commandEdited(mutableCommand1);
-    }
-
-    @Test
-    public void testSetSelectedCommandNetwork_Empty() throws Exception {
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandNetwork());
-        instance.setSelectedCommandNetwork(Optional.of("network"));
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandNetwork());
-        verify(listener, never()).commandEdited(any());
-    }
-
-    @Test
-    public void testSetSelectedCommandNetwork() throws Exception {
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandNetwork());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        instance.setSelectedCommandNetwork(Optional.of("network"));
-        assertEquals(Optional.of("network"), instance.getSelectedCommandNetwork());
-        verify(listener).commandEdited(mutableCommand1);
-    }
-
-    @Test
-    public void testSetSelectedCommandProfile_Empty() throws Exception {
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandProfile());
-        instance.setSelectedCommandProfile(Optional.of("profile"));
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandProfile());
-        verify(listener, never()).commandEdited(any());
-    }
-
-    @Test
-    public void testSetSelectedCommandProfile() throws Exception {
-        assertEquals(Optional.<String>empty(), instance.getSelectedCommandProfile());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        instance.setSelectedCommandProfile(Optional.of("profile"));
-        assertEquals(Optional.of("profile"), instance.getSelectedCommandProfile());
-        verify(listener).commandEdited(mutableCommand1);
-    }
-
-    @Test
-    public void testSetSelectedCommandResponse_Empty() throws Exception {
-        assertEquals("", instance.getSelectedCommandResponse());
-        instance.setSelectedCommandResponse("response");
-        assertEquals("", instance.getSelectedCommandResponse());
-        verify(listener, never()).commandEdited(any());
-    }
-
-    @Test(expected = NullPointerException.class)
-    public void testSetSelectedCommandResponse_Null() throws Exception {
-        assertEquals("", instance.getSelectedCommandResponse());
-        instance.setSelectedCommandResponse(null);
-        verify(listener, never()).commandEdited(any());
-    }
-
-    @Test
-    public void testSetSelectedCommandResponse() throws Exception {
-        assertEquals("", instance.getSelectedCommandResponse());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        instance.setSelectedCommandResponse("response");
-        assertEquals("response", instance.getSelectedCommandResponse());
-        verify(listener).commandEdited(mutableCommand1);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testSetSelectedCommandResponse_EmptyResponse() throws Exception {
-        assertEquals("", instance.getSelectedCommandResponse());
-        instance.setSelectedCommand(Optional.of(mutableCommand1));
-        instance.setSelectedCommandResponse("");
-        assertEquals("response", instance.getSelectedCommandResponse());
-        verify(listener, never()).commandEdited(any());
-    }
-
-    @Test
-    public void testAddCommand() throws Exception {
-        assertEquals(4, instance.getAutoCommands().size());
-        assertFalse(instance.getAutoCommands().contains(mutableCommand5));
-        instance.addCommand(mutableCommand5);
-        assertEquals(5, instance.getAutoCommands().size());
-        assertTrue(instance.getAutoCommands().contains(mutableCommand5));
-        verify(listener).commandAdded(mutableCommand5);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testAddCommand_exists() throws Exception {
-        assertEquals(4, instance.getAutoCommands().size());
-        assertTrue(instance.getAutoCommands().contains(mutableCommand4));
-        instance.addCommand(mutableCommand4);
-        verify(listener, never()).commandAdded(any());
-    }
-
-    @Test
-    public void testRemoveCommand() throws Exception {
-        assertEquals(4, instance.getAutoCommands().size());
-        assertTrue(instance.getAutoCommands().contains(mutableCommand4));
-        instance.removeCommand(mutableCommand4);
-        assertEquals(3, instance.getAutoCommands().size());
-        assertFalse(instance.getAutoCommands().contains(mutableCommand4));
-        verify(listener).commandRemoved(mutableCommand4);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testRemoveCommand_NotContains() throws Exception {
-        assertEquals(4, instance.getAutoCommands().size());
-        assertFalse(instance.getAutoCommands().contains(mutableCommand5));
-        instance.removeCommand(mutableCommand5);
-        verify(listener, never()).commandRemoved(any());
-    }
-
-    @Test
-    public void testSave() throws Exception {
-        instance.addCommand(mutableCommand5);
-        instance.removeCommand(mutableCommand1);
-        instance.save();
-        verify(manager).removeAutoCommand(mutableCommand1.getAutoCommand());
-        verify(manager).removeAutoCommand(mutableCommand2.getAutoCommand());
-        verify(manager).removeAutoCommand(mutableCommand3.getAutoCommand());
-        verify(manager).removeAutoCommand(mutableCommand4.getAutoCommand());
-        verify(manager, never()).addAutoCommand(mutableCommand1.getAutoCommand());
-        verify(manager).addAutoCommand(mutableCommand2.getAutoCommand());
-        verify(manager).addAutoCommand(mutableCommand3.getAutoCommand());
-        verify(manager).addAutoCommand(mutableCommand4.getAutoCommand());
-        verify(manager).addAutoCommand(mutableCommand5.getAutoCommand());
-    }
-}