Remove Logger.assertTrue.

Use Guava's Preconditions instead, which throw appropriate exceptions
rather than AssertionErrors (whose idea was that?!)

Also fix weirdness in CommandArguments where start was allowed to be
1 greater than end when getting words.

Change-Id: Icce38e36da6507f645fb8b3b872dfe2c60c43ea7
Reviewed-on: http://gerrit.dmdirc.com/2961
Reviewed-by: Greg Holmes <greg@dmdirc.com>
Automatic-Compile: DMDirc Build Manager

src/com/dmdirc/FrameContainerComparator.java

 
 package com.dmdirc;
 
-import com.dmdirc.logger.Logger;
-
 import java.io.Serializable;
 import java.util.Comparator;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * Compares FrameContainers by name.
  */
-public final class FrameContainerComparator implements Comparator<FrameContainer>,
-        Serializable {
+public class FrameContainerComparator implements Comparator<FrameContainer>, Serializable {
 
     /**
      * A version number for this class. It should be changed whenever the class
         "item2.toString() returns a non-null value"
     })
     public int compare(final FrameContainer item1, final FrameContainer item2) {
-        Logger.assertTrue(item1 != null);
-        Logger.assertTrue(item2 != null);
-        Logger.assertTrue(item1.getName() != null);
-        Logger.assertTrue(item2.getName() != null);
+        checkNotNull(item1);
+        checkNotNull(item2);
+        checkNotNull(item1.getName());
+        checkNotNull(item2.getName());
 
         if (sortBefore(item1, item2)) {
             return -1;
      * @param item2 The existing container to test against
      * @return True iff the new container should be before the old container
      */
-    private static boolean sortBefore(final FrameContainer item1,
+    private static boolean sortBefore(
+            final FrameContainer item1,
             final FrameContainer item2) {
-
         return getPosition(item1) < getPosition(item2);
     }
 

src/com/dmdirc/Server.java

 
 import lombok.extern.slf4j.Slf4j;
 
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * The Server class represents the client's view of a server. It maintains
  * a list of all channels, queries, etc, and handles parser callbacks pertaining
         "The current profile specifies at least one nickname"
     })
     private MyInfo buildMyInfo() {
-        Logger.assertTrue(profile != null);
-        Logger.assertTrue(!profile.getOptionList(DOMAIN_PROFILE, "nicknames").isEmpty());
+        checkNotNull(profile);
+        checkArgument(!profile.getOptionList(DOMAIN_PROFILE, "nicknames").isEmpty());
 
         final MyInfo myInfo = new MyInfo();
         myInfo.setNickname(profile.getOptionList(DOMAIN_PROFILE, "nicknames").get(0));

src/com/dmdirc/ServerManager.java

 import javax.inject.Provider;
 import javax.inject.Singleton;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
 /**
  * The ServerManager maintains a list of all servers, and provides methods to
  * search or iterate over them.
      * @since 0.6.3
      */
     public Server connectToAddress(final URI uri, final ConfigProvider profile) {
-        Logger.assertTrue(profile.isProfile());
+        checkArgument(profile.isProfile());
         Server server = null;
 
         for (Server loopServer : servers) {

src/com/dmdirc/actions/ActionComponentChain.java

 import com.dmdirc.Precondition;
 import com.dmdirc.interfaces.ActionController;
 import com.dmdirc.interfaces.actions.ActionComponent;
-import com.dmdirc.logger.Logger;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
 /**
  * An action component chain supports chaining of multiple action components
  * together.
     @Precondition("This component chain has one or more components")
     @Override
     public Class<?> appliesTo() {
-        Logger.assertTrue(!components.isEmpty());
+        checkArgument(!components.isEmpty());
 
         return components.get(0).appliesTo();
     }
     @Precondition("This component chain has one or more components")
     @Override
     public Class<?> getType() {
-        Logger.assertTrue(!components.isEmpty());
+        checkArgument(!components.isEmpty());
 
         return components.get(components.size() - 1).getType();
     }
     @Precondition("This component chain has one or more components")
     @Override
     public String getName() {
-        Logger.assertTrue(!components.isEmpty());
+        checkArgument(!components.isEmpty());
 
         final StringBuilder name = new StringBuilder();
 
     @Override
     @Precondition("This component chain has one or more components")
     public String toString() {
-        Logger.assertTrue(!components.isEmpty());
+        checkArgument(!components.isEmpty());
 
         final StringBuilder name = new StringBuilder();
 

src/com/dmdirc/actions/ActionGroup.java

 
 import com.dmdirc.Precondition;
 import com.dmdirc.config.prefs.PreferencesSetting;
-import com.dmdirc.logger.Logger;
 import com.dmdirc.updater.Version;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * Represents a group of actions, along with their meta-data.
  */
     })
     @SuppressWarnings("deprecation")
     public void deleteAction(final Action action) {
-        Logger.assertTrue(action != null);
-        Logger.assertTrue(actions.contains(action));
+        checkNotNull(action);
+        checkArgument(actions.contains(action));
 
         ActionManager.getActionManager().removeAction(action);
         action.delete();

src/com/dmdirc/actions/ActionManager.java

 import com.dmdirc.interfaces.config.IdentityController;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
-import com.dmdirc.updater.UpdateChecker;
 import com.dmdirc.updater.components.ActionGroupComponent;
 import com.dmdirc.updater.manager.UpdateManager;
 import com.dmdirc.util.collections.MapList;
 
 import lombok.extern.slf4j.Slf4j;
 
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * Manages all actions for the client.
  */
     @Override
     public void registerTypes(final ActionType[] newTypes) {
         for (ActionType type : newTypes) {
-            Logger.assertTrue(type != null);
+            checkNotNull(type);
 
             if (!types.contains(type)) {
                 log.debug("Registering action type: {}", type);
     @Override
     public void registerComponents(final ActionComponent[] comps) {
         for (ActionComponent comp : comps) {
-            Logger.assertTrue(comp != null);
+            checkNotNull(comp);
 
             log.debug("Registering action component: {}", comp);
             components.add(comp);
     @Override
     public void registerComparisons(final ActionComparison[] comps) {
         for (ActionComparison comp : comps) {
-            Logger.assertTrue(comp != null);
+            checkNotNull(comp);
 
             log.debug("Registering action comparison: {}", comp);
             comparisons.add(comp);
      */
     @Precondition("The specified File is not null and represents a directory")
     private void loadActions(final File dir) {
-        Logger.assertTrue(dir != null);
-        Logger.assertTrue(dir.isDirectory());
+        checkNotNull(dir);
+        checkArgument(dir.isDirectory());
 
         log.debug("Loading actions from directory: {}", dir.getAbsolutePath());
 
     /** {@inheritDoc} */
     @Override
     public void addAction(final Action action) {
-        Logger.assertTrue(action != null);
+        checkNotNull(action);
 
         log.debug("Registering action: {}/{} (status: {})",
                 new Object[] { action.getGroup(), action.getName(), action.getStatus() });
     /** {@inheritDoc} */
     @Override
     public void removeAction(final Action action) {
-        Logger.assertTrue(action != null);
+        checkNotNull(action);
 
         actions.removeFromAll(action);
         getOrCreateGroup(action.getGroup()).remove(action);
     @Override
     public boolean triggerEvent(final ActionType type,
             final StringBuffer format, final Object ... arguments) {
-        Logger.assertTrue(type != null);
-        Logger.assertTrue(type.getType() != null);
-        Logger.assertTrue(type.getType().getArity() == arguments.length);
+        checkNotNull(type);
+        checkNotNull(type.getType());
+        checkArgument(type.getType().getArity() == arguments.length);
 
         log.trace("Calling listeners for event of type {}", type);
 
     @Precondition("The specified ActionType is not null")
     private boolean triggerActions(final ActionType type,
             final StringBuffer format, final Object ... arguments) {
-        Logger.assertTrue(type != null);
+        checkNotNull(type);
 
         boolean res = false;
 
     /** {@inheritDoc} */
     @Override
     public ActionGroup createGroup(final String group) {
-        Logger.assertTrue(group != null);
-        Logger.assertTrue(!group.isEmpty());
-        Logger.assertTrue(!groups.containsKey(group));
+        checkNotNull(group);
+        checkArgument(!group.isEmpty());
+        checkArgument(!groups.containsKey(group));
 
         final File file = new File(getDirectory() + group);
         if (file.isDirectory() || file.mkdir()) {
     /** {@inheritDoc} */
     @Override
     public void deleteGroup(final String group) {
-        Logger.assertTrue(group != null);
-        Logger.assertTrue(!group.isEmpty());
-        Logger.assertTrue(groups.containsKey(group));
+        checkNotNull(group);
+        checkArgument(!group.isEmpty());
+        checkArgument(groups.containsKey(group));
 
         for (Action action : groups.get(group).getActions()) {
             removeAction(action);
     /** {@inheritDoc} */
     @Override
     public void changeGroupName(final String oldName, final String newName) {
-        Logger.assertTrue(oldName != null);
-        Logger.assertTrue(!oldName.isEmpty());
-        Logger.assertTrue(newName != null);
-        Logger.assertTrue(!newName.isEmpty());
-        Logger.assertTrue(groups.containsKey(oldName));
-        Logger.assertTrue(!groups.containsKey(newName));
-        Logger.assertTrue(!newName.equals(oldName));
+        checkNotNull(oldName);
+        checkArgument(!oldName.isEmpty());
+        checkNotNull(newName);
+        checkArgument(!newName.isEmpty());
+        checkArgument(groups.containsKey(oldName));
+        checkArgument(!groups.containsKey(newName));
+        checkArgument(!newName.equals(oldName));
 
         createGroup(newName);
 
     /** {@inheritDoc} */
     @Override
     public List<ActionType> findCompatibleTypes(final ActionType type) {
-        Logger.assertTrue(type != null);
+        checkNotNull(type);
 
         final List<ActionType> res = new ArrayList<>();
         for (ActionType target : types) {
     /** {@inheritDoc} */
     @Override
     public List<ActionComponent> findCompatibleComponents(final Class<?> target) {
-        Logger.assertTrue(target != null);
+        checkNotNull(target);
 
         final List<ActionComponent> res = new ArrayList<>();
         for (ActionComponent subject : components) {
     /** {@inheritDoc} */
     @Override
     public List<ActionComparison> findCompatibleComparisons(final Class<?> target) {
-        Logger.assertTrue(target != null);
+        checkNotNull(target);
 
         final List<ActionComparison> res = new ArrayList<>();
         for (ActionComparison subject : comparisons) {
     /** {@inheritDoc} */
     @Override
     public ActionComponent getComponent(final String type) {
-        Logger.assertTrue(type != null);
-        Logger.assertTrue(!type.isEmpty());
+        checkNotNull(type);
+        checkArgument(!type.isEmpty());
 
         for (ActionComponent target : components) {
             if (target.name().equals(type)) {
     /** {@inheritDoc} */
     @Override
     public ActionComparison getComparison(final String type) {
-        Logger.assertTrue(type != null);
-        Logger.assertTrue(!type.isEmpty());
+        checkNotNull(type);
+        checkArgument(!type.isEmpty());
 
         for (ActionComparison target : comparisons) {
             if (target.name().equals(type)) {

src/com/dmdirc/commandparser/CommandArguments.java

 
 import com.dmdirc.Precondition;
 import com.dmdirc.interfaces.CommandController;
-import com.dmdirc.logger.Logger;
 
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import static com.google.common.base.Preconditions.checkPositionIndex;
+
 /**
  * Represents a command and its arguments. In this class, input is split into
  * 'words' which are separated by any number of whitespace characters;
     public String getArgumentsAsString(final int start) {
         parse();
 
-        return getArgumentsAsString(start, words.length - 2);
+        return getArgumentsAsString(start, Math.max(start, words.length - 2));
     }
 
     /**
      */
     @Precondition("Start index is less than or equal to end index")
     public String getWordsAsString(final int start, final int end) {
-        Logger.assertTrue(start <= end + 1);
+        checkPositionIndex(start, end);
 
         final Pattern pattern = Pattern.compile("(\\S+\\s+){" + start + "}"
                 + "((\\S+\\s+){" + Math.max(0, end - start) + "}\\S+(\\s+$)?).*?");

src/com/dmdirc/config/IdentityManager.java

 
 import lombok.extern.slf4j.Slf4j;
 
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * The identity manager manages all known identities, providing easy methods
  * to access them.
         "The specified File is a directory"
     })
     private void loadUser(final File dir) {
-        Logger.assertTrue(dir != null);
-        Logger.assertTrue(dir.isDirectory());
+        checkNotNull(dir);
+        checkArgument(dir.isDirectory());
 
         if (dir.listFiles() == null) {
             Logger.userError(ErrorLevel.MEDIUM,
     /** {@inheritDoc} */
     @Override
     public void addConfigProvider(final ConfigProvider identity) {
-        Logger.assertTrue(identity != null);
+        checkNotNull(identity);
 
         final String target = getGroup(identity);
 
     /** {@inheritDoc} */
     @Override
     public void removeConfigProvider(final ConfigProvider identity) {
-        Logger.assertTrue(identity != null);
+        checkNotNull(identity);
 
         final String group = getGroup(identity);
 
-        Logger.assertTrue(identities.containsValue(group, identity));
+        checkArgument(identities.containsValue(group, identity));
 
         synchronized (identities) {
             identities.remove(group, identity);
     /** {@inheritDoc} */
     @Override
     public void registerIdentityListener(final String type, final ConfigProviderListener listener) {
-        Logger.assertTrue(listener != null);
+        checkNotNull(listener);
 
         synchronized (listeners) {
             listeners.add(type, listener);

src/com/dmdirc/logger/Logger.java

         getErrorManager().addError(level, message, exception, true);
     }
 
-    /**
-     * Asserts that the specified value is true. If not, an AssertionError
-     * exception is thrown.
-     *
-     * @param value The value to be tested
-     */
-    public static void assertTrue(final boolean value) {
-        if (!value) {
-            throw new AssertionError();
-        }
-    }
-
     /**
      * Gets the manager that should be used to report errors.
      *

src/com/dmdirc/ui/WindowManager.java

 import com.dmdirc.Precondition;
 import com.dmdirc.interfaces.FrameCloseListener;
 import com.dmdirc.interfaces.ui.FrameListener;
-import com.dmdirc.logger.Logger;
 import com.dmdirc.util.collections.ListenerList;
 
 import java.util.Collection;
 import javax.inject.Inject;
 import javax.inject.Singleton;
 
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * The WindowManager maintains a list of all open windows, and their
  * parent/child relations.
      */
     @Precondition("The specified FrameListener is not null")
     public void addListener(final FrameListener frameListener) {
-        Logger.assertTrue(frameListener != null);
+        checkNotNull(frameListener);
 
         listeners.add(FrameListener.class, frameListener);
     }
         "The specified Window has not already been added"
     })
     public void addWindow(final FrameContainer window, final boolean focus) {
-        Logger.assertTrue(window != null);
-        Logger.assertTrue(!rootWindows.contains(window));
+        checkNotNull(window);
+        checkArgument(!rootWindows.contains(window));
 
         rootWindows.add(window);
 
     })
     public void addWindow(final FrameContainer parent,
             final FrameContainer child, final boolean focus) {
-        Logger.assertTrue(parent != null);
-        Logger.assertTrue(isInHierarchy(parent));
-        Logger.assertTrue(child != null);
-        Logger.assertTrue(!isInHierarchy(child));
+        checkNotNull(parent);
+        checkArgument(isInHierarchy(parent));
+        checkNotNull(child);
+        checkArgument(!isInHierarchy(child));
 
         parent.addChild(child);
 
         "The specified window is in the window hierarchy"
     })
     public void removeWindow(final FrameContainer window) {
-        Logger.assertTrue(isInHierarchy(window));
-        Logger.assertTrue(window != null);
+        checkNotNull(window != null);
+        checkArgument(isInHierarchy(window));
 
         for (FrameContainer child : window.getChildren()) {
             child.close();
      */
     @Precondition("The specified window name is not null")
     public FrameContainer findCustomWindow(final String name) {
-        Logger.assertTrue(name != null);
+        checkNotNull(name);
 
         return findCustomWindow(rootWindows, name);
     }
         "The specified parent window is not null",
         "The specified parent window has been added to the Window Manager"
     })
-    public FrameContainer findCustomWindow(final FrameContainer parent,
-            final String name) {
-        Logger.assertTrue(parent != null);
-        Logger.assertTrue(name != null);
+    public FrameContainer findCustomWindow(final FrameContainer parent, final String name) {
+        checkNotNull(parent);
+        checkNotNull(name);
 
         return findCustomWindow(parent.getChildren(), name);
     }