Tidy

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

gradle/wrapper/gradle-wrapper.properties

-#Sun Sep 14 22:29:29 BST 2014
+#Tue Sep 16 15:02:24 BST 2014
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-2.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.1-bin.zip

src/com/dmdirc/util/SimpleInjector.java

      * @param parents The injectors to inherit parameters from.
      */
     public SimpleInjector(final SimpleInjector ... parents) {
-        this.parents = parents;
+        this.parents = new SimpleInjector[parents.length];
+        System.arraycopy(parents, 0, this.parents, 0, parents.length);
     }
 
     /**
     /**
      * Adds the specified object as an injectable parameter for all of its
      * known classes and interface. This is equivalent to calling
-     * {@link #addParameter(java.lang.Class, java.lang.Object)} for the object's
+     * {@link #addParameter(Class, Object)} for the object's
      * class, all superclasses, and all interfaces.
      *
      * @param object The object to be injected

src/com/dmdirc/util/collections/ListenerList.java

 
     /**
      * Utility class to handle calls to a "callable" interface as returned by
-     * {@link #getCallable(java.lang.Class)}.
+     * {@link #getCallable(Class)}.
      *
      * @param <T> The type of listener being called
      */

src/com/dmdirc/util/collections/MapList.java

  * synchronized externally.
  * <p>
  * The <code>List</code>s used to back this map are synchronized using the
- * {@link Collections#synchronizedList(java.util.List)} method, which requires
+ * {@link Collections#synchronizedList(List)} method, which requires
  * manual synchronization in any code iterating over the values.
  *
  * @param <S> the type of keys maintained by this map

src/com/dmdirc/util/collections/RollingList.java

      * @return True if there is an element, false otherwise.
      */
     public boolean hasNext() {
-        return (items.size() > position + 1) || ((items.size() > position)
-                && addEmpty);
+        return items.size() > position + 1 || items.size() > position && addEmpty;
     }
 
     /**

test/com/dmdirc/util/CommandUtilsTest.java

 
     @Test
     public void testParseArguments() {
-        final String[][][] tests = new String[][][]{
+        final String[][][] tests = {
             {{"abcdef abcdef abcdef"}, {"abcdef", "abcdef", "abcdef"}},
             {{"abcdef \"abcdef abcdef\""}, {"abcdef", "abcdef abcdef"}},
             {{"abcdef \"abcdef foo abcdef\""}, {"abcdef", "abcdef foo abcdef"}},

test/com/dmdirc/util/ReturnableThreadTest.java

         assertSame(result, instance.getObject());
     }
 
-    private class RetunableThreadImpl extends ReturnableThread {
+    private static class RetunableThreadImpl extends ReturnableThread {
         @Override
         public void run() {
         }

test/com/dmdirc/util/SimpleInjectorTest.java

         assertNull(result);
     }
 
-    class TestObject implements Serializable {
+    static class TestObject implements Serializable {
 
         public TestObject(final String test) { // NOPMD
         }
     }
 
-    class PrivateObject implements Serializable {
+    static class PrivateObject implements Serializable {
 
         private PrivateObject() {
         }
     }
 
-    class ExceptionObject implements Serializable {
+    static class ExceptionObject implements Serializable {
 
         public ExceptionObject() {
             throw new IndexOutOfBoundsException();

test/com/dmdirc/util/collections/DoubleMapTest.java

 
 package com.dmdirc.util.collections;
 
+import java.util.Map;
+
 import org.junit.Test;
 import static org.junit.Assert.*;
 
 
     @Test
     public void testPut() {
-        final DoubleMap<String, String> dm = new DoubleMap<>();
+        final Map<String, String> dm = new DoubleMap<>();
         dm.put("a", "b");
         
         assertEquals(1, dm.keySet().size());
     
     @Test(expected=NullPointerException.class)
     public void testPutNull1() {
-        final DoubleMap<String, String> dm = new DoubleMap<>();
+        final Map<String, String> dm = new DoubleMap<>();
         dm.put(null, "b");
     }
     
     @Test(expected=NullPointerException.class)
     public void testPutNull2() {
-        final DoubleMap<String, String> dm = new DoubleMap<>();
+        final Map<String, String> dm = new DoubleMap<>();
         dm.put("a", null);
     }    
     

test/com/dmdirc/util/collections/EquatableWeakReferenceTest.java

 
         assertTrue(ewf.equals(myObject));
         assertTrue(ewf.equals(myRef));
-        assertFalse(ewf.equals("bar"));
+        assertFalse("bar".equals(ewf));
         assertFalse(ewf.equals(new WeakReference<Object>("bar")));
     }
 

test/com/dmdirc/util/collections/ListenerListTest.java

     @Test
     public void testGenericGetListeners() {
         final Object listener = new Object();
-        final String listener2 = "";
         final ListenerList instance = new ListenerList();
         assertTrue(instance.get(Object.class).isEmpty());
         instance.add(Object.class, listener);
         assertTrue(instance.get(Object.class).contains(listener));
         assertTrue(instance.get(String.class).isEmpty());
+        final String listener2 = "";
         instance.add(String.class, listener2);
         assertTrue(instance.get(String.class).contains(listener2));
     }
     @Test
     public void testStringGetListeners() {
         final Object listener = new Object();
-        final String listener2 = "";
         final ListenerList instance = new ListenerList();
         assertTrue(instance.get("Object").isEmpty());
         instance.add("Object", listener);
         assertTrue(instance.get("Object").contains(listener));
         assertTrue(instance.get("String").isEmpty());
+        final String listener2 = "";
         instance.add("String", listener2);
         assertTrue(instance.get("String").contains(listener2));
     }

test/com/dmdirc/util/collections/MapListTest.java

 package com.dmdirc.util.collections;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 import org.junit.Test;
     @Test
     public void testAddCollection() {
         final MapList<String, String> test = new MapList<>();
-        final List<String> testList = new ArrayList<>();
+        final Collection<String> testList = new ArrayList<>();
         testList.add("d");
         testList.add("e");
         test.add("key", testList);

test/com/dmdirc/util/collections/WeakListTest.java

 package com.dmdirc.util.collections;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 
     @Test
     public void testIsEmpty() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         assertTrue(instance.isEmpty());
         instance.add("test1");
         assertFalse(instance.isEmpty());
 
     @Test
     public void testAdd() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         assertTrue(instance.add("test1"));
         assertFalse(instance.isEmpty());
     }
 
     @Test
     public void testAddInt() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         assertTrue(instance.add("test1"));
         instance.add(0, "test2");
         assertEquals("test2", instance.get(0));
 
     @Test
     public void testRemove() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.add("test1");
         assertFalse(instance.isEmpty());
         assertTrue(instance.remove("test1"));
 
     @Test
     public void testRemoveInt() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         assertTrue(instance.isEmpty());
         instance.add("test1");
         instance.add("test2");
         assertEquals(2, instance.size());
         instance.remove(1);
-        assertTrue(instance.contains(("test1")));
-        assertFalse(instance.contains(("test2")));
+        assertTrue(instance.contains("test1"));
+        assertFalse(instance.contains("test2"));
     }
 
     @Test
     public void testGet() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.add("test1");
         instance.add("test2");
         assertEquals("test1", instance.get(0));
 
     @Test
     public void testContains() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         assertFalse(instance.contains("test1"));
         instance.add("test1");
         assertTrue(instance.contains("test1"));
      */
     @Test
     public void testToArray0args() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         assertEquals(0, instance.toArray().length);
         instance.add("test1");
         instance.add("test2");
      */
     @Test
     public void testToArrayGenericType() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         assertEquals(0, instance.toArray(new String[instance.size()]).length);
         instance.add("test1");
         instance.add("test2");
      */
     @Test
     public void testContainsAllAddAll() {
-        final List<String> list = new ArrayList<>();
+        final Collection<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         assertFalse(instance.containsAll(list));
         instance.addAll(list);
         assertTrue(instance.contains("test1"));
 
     @Test
     public void testAddAllIntCollection() {
-        final List<String> list = new ArrayList<>();
+        final Collection<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.add("test3");
         System.out.println(instance);
         assertEquals("test3", instance.get(0));
     @Test
     public void testIndexOf() {
         final String one = "test1";
-        final String two = "test2";
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.add(one);
+        final String two = "test2";
         instance.add(two);
         assertEquals(2, instance.size());
         assertEquals(0, instance.indexOf(one));
     @Test
     public void testLastIndexOf() {
         final String one = "test1";
-        final String two = "test2";
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.add(one);
+        final String two = "test2";
         instance.add(two);
         instance.add(one);
         assertEquals(3, instance.size());
 
     @Test
     public void testRemoveAll() {
-        final List<String> list = new ArrayList<>();
+        final Collection<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.addAll(list);
         assertFalse(instance.isEmpty());
         instance.removeAll(list);
 
     @Test
     public void testRetainAll() {
-        final List<String> list = new ArrayList<>();
+        final Collection<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.addAll(list);
         instance.add("test3");
         instance.add("test4");
 
     @Test
     public void testClear() {
-        final List<String> list = new ArrayList<>();
+        final Collection<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.addAll(list);
         assertFalse(instance.isEmpty());
         instance.clear();
 
     @Test
     public void testSet() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.add("test1");
         assertEquals("test1", instance.get(0));
         instance.set(0, "test2");
 
     @Test
     public void testIterator() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         Iterator result = instance.iterator();
         assertFalse(result.hasNext());
         instance.add("test1");
 
     @Test
     public void testListIterator0args() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         ListIterator result = instance.listIterator();
         assertFalse(result.hasNext());
         instance.add("test1");
 
     @Test(expected=IndexOutOfBoundsException.class)
     public void testListIteratorInt() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         ListIterator result = instance.listIterator(1);
         assertFalse(result.hasNext());
         instance.add("test1");
 
     @Test
     public void testSubList() {
-        final WeakList<String> instance = new WeakList<>();
+        final List<String> instance = new WeakList<>();
         instance.add("test1");
         instance.add("test2");
         instance.add("test3");

test/com/dmdirc/util/validators/DisabledOptionValidatorTest.java

 
     @Test
     public void testValidateNull() {
-        final DisabledOptionValidator instance = new DisabledOptionValidator();
+        final Validator instance = new DisabledOptionValidator();
         assertFalse(instance.validate(null).isFailure());
     }
 
     @Test
     public void testValidateFalse() {
-        final DisabledOptionValidator instance = new DisabledOptionValidator();
+        final Validator instance = new DisabledOptionValidator();
         assertTrue(instance.validate("false:moo").isFailure());
     }
 
     @Test
     public void testValidateTrue() {
-        final DisabledOptionValidator instance = new DisabledOptionValidator();
+        final Validator instance = new DisabledOptionValidator();
         assertFalse(instance.validate("true:moo").isFailure());
     }
 }

test/com/dmdirc/util/validators/FileNameValidatorTest.java

 
     @Test
     public void testValidate() {
-        final FileNameValidator rv = new FileNameValidator();
+        final Validator rv = new FileNameValidator();
         
         assertTrue(rv.validate("/foo").isFailure());
         assertFalse(rv.validate("filename").isFailure());

test/com/dmdirc/util/validators/NotEmptyValidatorTest.java

 
     @Test
     public void testValidate() {
-        final NotEmptyValidator nev = new NotEmptyValidator();
+        final Validator nev = new NotEmptyValidator();
         
         assertTrue(nev.validate("").isFailure());
-        assertTrue(nev.validate("").getFailureReason().indexOf("empty") > -1);
+        assertTrue(nev.validate("").getFailureReason().contains("empty"));
         assertFalse(nev.validate("moo").isFailure());
         assertFalse(nev.validate(" ").isFailure());
     }

test/com/dmdirc/util/validators/NumericalValidatorTest.java

         final ValidationResponse vr = new NumericalValidator(3, 5).validate("foo");
 
         assertTrue(vr.isFailure());
-        assertTrue(vr.getFailureReason().indexOf("number") > -1);
+        assertTrue(vr.getFailureReason().contains("number"));
     }
 
     @Test
     public void testMin() {
-        final NumericalValidator nv1 = new NumericalValidator(-1, -1);
-        final NumericalValidator nv2 = new NumericalValidator(-5, -1);
+        final Validator nv1 = new NumericalValidator(-1, -1);
+        final Validator nv2 = new NumericalValidator(-5, -1);
 
         assertFalse(nv1.validate("-5").isFailure());
         assertFalse(nv2.validate("-5").isFailure());
 
     @Test
     public void testMax() {
-        final NumericalValidator nv1 = new NumericalValidator(-1, -1);
-        final NumericalValidator nv2 = new NumericalValidator(-1, 10);
+        final Validator nv1 = new NumericalValidator(-1, -1);
+        final Validator nv2 = new NumericalValidator(-1, 10);
 
         assertFalse(nv1.validate("-5").isFailure());
         assertFalse(nv1.validate("50").isFailure());

test/com/dmdirc/util/validators/OptionalValidatorTest.java

     @Test
     public void testNullValue() {
         final Validator<String> validator = new NotEmptyValidator();
-        final OptionalValidator instance = new OptionalValidator(validator);
+        final Validator instance = new OptionalValidator(validator);
         assertTrue(instance.validate(null).isFailure());
     }
 

test/com/dmdirc/util/validators/RegexStringValidatorTest.java

     @Test
     public void testValidate() {
         final String reason = "abc 123";
-        final RegexStringValidator rv = new RegexStringValidator("[0-9]{5}", reason);
+        final Validator rv = new RegexStringValidator("[0-9]{5}", reason);
         
         assertTrue(rv.validate("abc").isFailure());
         assertEquals(reason, rv.validate("abc").getFailureReason());

test/com/dmdirc/util/validators/RegexValidatorTest.java

 
     @Test
     public void testValidate() {
-        final RegexValidator rv = new RegexValidator();
+        final Validator rv = new RegexValidator();
         
         assertTrue(rv.validate("****").isFailure());
         assertFalse(rv.validate("[a-z]").isFailure());

test/com/dmdirc/util/validators/StringLengthValidatorTest.java

 
     @Test
     public void testUnlimited() {
-        final StringLengthValidator slv = new StringLengthValidator(-1, 10);
+        final Validator slv = new StringLengthValidator(-1, 10);
         
         assertFalse(slv.validate("123").isFailure());
         assertFalse(slv.validate("").isFailure());
         assertFalse(slv.validate("123456789").isFailure());
         
-        final StringLengthValidator slv2 = new StringLengthValidator(0, -1);
+        final Validator slv2 = new StringLengthValidator(0, -1);
         
         assertFalse(slv2.validate("123456789").isFailure());
         assertFalse(slv2.validate("1").isFailure());
     
     @Test
     public void testMinimum() {
-        final StringLengthValidator slv = new StringLengthValidator(5, 100);
+        final Validator slv = new StringLengthValidator(5, 100);
         
         assertTrue(slv.validate("").isFailure());
         assertTrue(slv.validate("123").isFailure());
         assertTrue(slv.validate("1234").isFailure());
-        assertTrue(slv.validate("1234").getFailureReason().indexOf("at least 5") > -1);
+        assertTrue(slv.validate("1234").getFailureReason().contains("at least 5"));
         assertFalse(slv.validate("12345").isFailure());
         assertFalse(slv.validate("12345789").isFailure());
     }
     
     @Test
     public void testMaximum() {
-        final StringLengthValidator slv = new StringLengthValidator(0, 3);
+        final Validator slv = new StringLengthValidator(0, 3);
         
         assertFalse(slv.validate("").isFailure());
         assertFalse(slv.validate("12").isFailure());
         assertFalse(slv.validate("123").isFailure());
         assertTrue(slv.validate("1234").isFailure());
-        assertTrue(slv.validate("1234").getFailureReason().indexOf("at most 3") > -1);
+        assertTrue(slv.validate("1234").getFailureReason().contains("at most 3"));
         assertTrue(slv.validate("12345").isFailure());
     }    
 

test/com/dmdirc/util/validators/URIValidatorTest.java

 
     @Test
     public void testValidateInvalidURI() {
-        final URIValidator instance = new URIValidator();
+        final Validator instance = new URIValidator();
         assertTrue(instance.validate("http://^").isFailure());
     }
 
     @Test
     public void testValidateValid() {
-        final URIValidator instance = new URIValidator();
+        final Validator instance = new URIValidator();
         assertFalse(instance.validate("http://google.com:80").isFailure());
     }
 }

test/com/dmdirc/util/validators/ValidatorChainTest.java

 
     @Test
     public void testValidate() {
-        @SuppressWarnings("unchecked")
-        final ValidatorChain<String> chain = new ValidatorChain<>(
+        final Validator<String> chain = new ValidatorChain<>(
                 new NotEmptyValidator(), new RegexStringValidator("[a-z]*", "abc"));
         
         assertTrue(chain.validate("").isFailure());