Java 7 conversions

Change-Id: Ib05f625f14ab2f486f0c83c47c860dd0f0ef3ba1
Reviewed-on: http://gerrit.dmdirc.com/2896
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/util/CommandUtils.java

      * @return An array of arguments corresponding to the command
      */
     public static String[] parseArguments(final String command) {
-        final List<String> args = new ArrayList<String>();
+        final List<String> args = new ArrayList<>();
         final StringBuilder builder = new StringBuilder();
         boolean inquote = false;
 

src/com/dmdirc/util/SimpleInjector.java

 package com.dmdirc.util;
 
 import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.Map;
 
     private final SimpleInjector[] parents;
 
     /** A mapping of known classes to the objects that should be injected. */
-    private final Map<Class<?>, Object> parameters
-            = new HashMap<Class<?>, Object>();
+    private final Map<Class<?>, Object> parameters = new HashMap<>();
 
     /**
      * Creates a new injector which will inherit injection parameters from
      * @return A map of injectable parameters
      */
     public Map<Class<?>, Object> getParameters() {
-        final Map<Class<?>, Object> localParams
-                = new HashMap<Class<?>, Object>(parameters.size());
+        final Map<Class<?>, Object> localParams = new HashMap<>(parameters.size());
 
         for (SimpleInjector parent : parents) {
             localParams.putAll(parent.getParameters());
             if (i == args.length) {
                 try {
                     return ctor.newInstance(args);
-                } catch (IllegalAccessException ex) {
+                } catch (ReflectiveOperationException ex) {
                     throwable = ex;
-                } catch (IllegalArgumentException ex) {
-                    throwable = ex;
-                } catch (InstantiationException ex) {
-                    throwable = ex;
-                } catch (InvocationTargetException ex) {
-                    throwable = ex;
-                } catch (LinkageError err) {
-                    throwable = err;
                 }
             }
         }

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

 public class DoubleMap<A,B> implements Map<A, B> {
 
     /** The keys in this map. */
-    protected final List<A> keys = new ArrayList<A>();
+    protected final List<A> keys = new ArrayList<>();
     /** The values in this map. */
-    protected final List<B> values = new ArrayList<B>();
+    protected final List<B> values = new ArrayList<>();
 
     /**
      * Retrieves the value associated with the specified key.
     /** {@inheritDoc} */
     @Override
     public Set<A> keySet() {
-        return new HashSet<A>(keys);
+        return new HashSet<>(keys);
     }
 
     /** {@inheritDoc} */
     /** {@inheritDoc} */
     @Override
     public Collection<B> values() {
-        return new ArrayList<B>(values);
+        return new ArrayList<>(values);
     }
 
     /** {@inheritDoc} */
     @Override
     public Set<Entry<A, B>> entrySet() {
-        final Set<Entry<A, B>> set = new HashSet<Entry<A, B>>();
+        final Set<Entry<A, B>> set = new HashSet<>();
         for (A key : keys) {
-            set.add(new SimpleEntry<A, B>(key, getValue(key)));
+            set.add(new SimpleEntry<>(key, getValue(key)));
         }
         return set;
     }

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

      * Creates a new, empty MapList.
      */
     public MapList() {
-        map = new HashMap<S, List<T>>();
+        map = new HashMap<>();
     }
 
     /**
      * @return This MapList's map.
      */
     public Map<S, List<T>> getMap() {
-        return new HashMap<S, List<T>>(map);
+        return new HashMap<>(map);
     }
 
 }

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

 public class RollingList<T> {
 
     /** The items in this rolling list. */
-    private final List<T> items = new ArrayList<T>();
+    private final List<T> items = new ArrayList<>();
     /** The maximum capacity of this list. */
     private final int capacity;
     /** Whether or not to add a fake empty item to the end of this list. */
      * @return A list of items in this rolling list.
      */
     public List<T> getList() {
-        return new ArrayList<T>(items);
+        return new ArrayList<>(items);
     }
 }

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

 public class WeakList<T> implements List<T> {
 
     /** The items in this list. */
-    private final List<WeakReference<T>> list
-            = new ArrayList<WeakReference<T>>();
+    private final List<WeakReference<T>> list = new ArrayList<>();
 
     /**
      * Removes any entries from the list that have been GC'd.
      * @return A list containing the items referenced by the specified list
      */
     private List<T> dereferenceList(final List<WeakReference<T>> list) {
-        final List<T> res = new ArrayList<T>();
+        final List<T> res = new ArrayList<>();
 
         for (WeakReference<T> item : list) {
             if (item.get() != null) {
     @SuppressWarnings({"unchecked", "rawtypes"})
     private Collection<WeakReference<T>> referenceCollection(
             final Collection<?> c) {
-        final Collection<WeakReference<T>> res
-                = new ArrayList<WeakReference<T>>();
+        final Collection<WeakReference<T>> res = new ArrayList<>();
 
         for (Object item : c) {
             res.add(new EquatableWeakReference(item));
     /** {@inheritDoc} */
     @Override
     public boolean add(final T e) {
-        return list.add(new EquatableWeakReference<T>(e));
+        return list.add(new EquatableWeakReference<>(e));
     }
 
     /** {@inheritDoc} */
     /** {@inheritDoc} */
     @Override
     public T set(final int index, final T element) {
-        list.set(index, new EquatableWeakReference<T>(element));
+        list.set(index, new EquatableWeakReference<>(element));
 
         return element;
     }
     /** {@inheritDoc} */
     @Override
     public void add(final int index, final T element) {
-        list.add(index, new EquatableWeakReference<T>(element));
+        list.add(index, new EquatableWeakReference<>(element));
     }
 
     /** {@inheritDoc} */

src/com/dmdirc/util/io/ConfigFile.java

 package com.dmdirc.util.io;
 
 import com.dmdirc.util.collections.MapList;
+
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 public class ConfigFile extends TextFile {
 
     /** A list of domains in this config file. */
-    private final List<String> domains = new ArrayList<String>();
+    private final List<String> domains = new ArrayList<>();
 
     /** The values associated with each flat domain. */
-    private final MapList<String, String> flatdomains
-            = new MapList<String, String>();
+    private final MapList<String, String> flatdomains = new MapList<>();
 
     /** The key/value sets associated with each key domain. */
-    private final Map<String, Map<String, String>> keydomains
-            = new HashMap<String, Map<String, String>>();
+    private final Map<String, Map<String, String>> keydomains = new HashMap<>();
 
     /** Whether or not we should automatically create domains. */
     private boolean automake;
                     + "that isn't writable");
         }
 
-        final List<String> lines = new ArrayList<String>();
+        final List<String> lines = new ArrayList<>();
 
         lines.add("# This is a DMDirc configuration file.");
         lines.add("# Written on: " + new GregorianCalendar().getTime()

src/com/dmdirc/util/io/Downloader.java

     public static List<String> getPage(final String url, final String postData)
             throws IOException {
 
-        final List<String> res = new ArrayList<String>();
+        final List<String> res = new ArrayList<>();
 
         final URLConnection urlConn = getConnection(url, postData);
 

src/com/dmdirc/util/io/ReverseFileReader.java

         }
         // Used to store result to output.
 
-        final ArrayList<Byte> line = new ArrayList<Byte>(seekLength);
+        final ArrayList<Byte> line = new ArrayList<>(seekLength);
         // Used to store position in file pre-read
         long fp = 0;
         // Used to store position in file when this is called
      * @return The requested lines
      */
     public Stack<String> getLines(final int numLines) {
-        final Stack<String> result = new Stack<String>();
+        final Stack<String> result = new Stack<>();
         for (int i = 0; i < numLines; ++i) {
             try {
                 result.push(getNextLine());

src/com/dmdirc/util/io/TextFile.java

             inputStream = file == null ? is : new FileInputStream(file);
             inputReader = new InputStreamReader(inputStream, charset);
             reader = new BufferedReader(inputReader);
-            lines = new ArrayList<String>();
+            lines = new ArrayList<>();
 
             String line;
 

src/com/dmdirc/util/validators/ValidatorChain.java

 public class ValidatorChain<A> implements Validator<A> {
 
     /** A list of validators to use. */
-    private final List<Validator<A>> validatorList
-            = new ArrayList<Validator<A>>();
+    private final List<Validator<A>> validatorList = new ArrayList<>();
 
     /**
      * Creates a new validator chain containing the specified validators.

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

 
     @Test
     public void testPut() {
-        final DoubleMap<String, String> dm = new DoubleMap<String, String>();
+        final DoubleMap<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<String, String>();
+        final DoubleMap<String, String> dm = new DoubleMap<>();
         dm.put(null, "b");
     }
     
     @Test(expected=NullPointerException.class)
     public void testPutNull2() {
-        final DoubleMap<String, String> dm = new DoubleMap<String, String>();
+        final DoubleMap<String, String> dm = new DoubleMap<>();
         dm.put("a", null);
     }    
     
     @Test
     public void testGet() {
-        final DoubleMap<String, String> dm = new DoubleMap<String, String>();
+        final DoubleMap<String, String> dm = new DoubleMap<>();
         dm.put("a", "b");
         dm.put("b", "c");
         dm.put("c", "a");

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

     @Test
     public void testEquals() {
         final Object myObject = "moo";
-        final Reference<Object> myRef = new WeakReference<Object>(myObject);
-        final EquatableWeakReference<Object> ewf = new EquatableWeakReference<Object>(myObject);
+        final Reference<Object> myRef = new WeakReference<>(myObject);
+        final EquatableWeakReference<Object> ewf = new EquatableWeakReference<>(myObject);
 
         assertTrue(ewf.equals(myObject));
         assertTrue(ewf.equals(myRef));
     @Test
     public void testHashCode() {
         final Object myObject = "moo";
-        final EquatableWeakReference<Object> ewf = new EquatableWeakReference<Object>(myObject);
+        final EquatableWeakReference<Object> ewf = new EquatableWeakReference<>(myObject);
         
         assertEquals(myObject.hashCode(), ewf.hashCode());
     }

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

 
     @Test
     public void testIsEmpty() {
-        final MapList<String, String> test = new MapList<String, String>();
+        final MapList<String, String> test = new MapList<>();
         assertTrue(test.isEmpty());
 
         test.add("a", "b");
 
     @Test
     public void testAddCollection() {
-        final MapList<String, String> test = new MapList<String, String>();
-        final List<String> testList = new ArrayList<String>();
+        final MapList<String, String> test = new MapList<>();
+        final List<String> testList = new ArrayList<>();
         testList.add("d");
         testList.add("e");
         test.add("key", testList);
 
     @Test
     public void testClear() {
-        final MapList<String, String> test = new MapList<String, String>();
+        final MapList<String, String> test = new MapList<>();
         test.add("a", "b");
         test.add("d", "e");
         test.clear();
 
     @Test
     public void testClearKey() {
-        final MapList<String, String> test = new MapList<String, String>();
+        final MapList<String, String> test = new MapList<>();
         test.add("a", "b");
         test.add("d", "e");
         test.clear("a");
 
     @Test
     public void testRemove() {
-        final MapList<String, String> test = new MapList<String, String>();
+        final MapList<String, String> test = new MapList<>();
         test.add("a", "b");
         test.add("d", "e");
         test.remove("z", "b");
 
     @Test
     public void testRemoveKey() {
-        final MapList<String, String> instance = new MapList<String, String>();
+        final MapList<String, String> instance = new MapList<>();
         instance.add("a", "b");
         assertTrue(instance.containsKey("a"));
         instance.remove("a");
 
     @Test
     public void testKeySet() {
-        final MapList<String, String> test = new MapList<String, String>();
+        final MapList<String, String> test = new MapList<>();
         test.add("a", "b");
         test.add("d", "e");
         assertEquals(2, test.keySet().size());
 
     @Test
     public void testContainsKey() {
-        final MapList<String, String> test = new MapList<String, String>();
+        final MapList<String, String> test = new MapList<>();
         test.add("a", "b");
         assertTrue(test.containsKey("a"));
     }
 
     @Test
     public void testContainsValue() {
-        final MapList<String, String> test = new MapList<String, String>();
+        final MapList<String, String> test = new MapList<>();
         test.add("a", "b");
         assertTrue(test.containsValue("a", "b"));
     }
 
     @Test
     public void testGet() {
-        final MapList<String, String> test = new MapList<String, String>();
+        final MapList<String, String> test = new MapList<>();
         test.add("a", "b");
         assertEquals(1, test.get("a").size());
         assertEquals("b", test.get("a").get(0));
 
     @Test
     public void testInherit() {
-        final MapList<String, String> test1 = new MapList<String, String>();
+        final MapList<String, String> test1 = new MapList<>();
         test1.add("a", "b");
 
-        final MapList<String, String> test2 = new MapList<String, String>(test1);
+        final MapList<String, String> test2 = new MapList<>(test1);
         assertEquals(1, test2.get("a").size());
         assertEquals("b", test2.get("a").get(0));
         assertEquals("b", test2.get("a", 0));
 
     @Test
     public void testGetMap() {
-        final MapList<String, String> test1 = new MapList<String, String>();
+        final MapList<String, String> test1 = new MapList<>();
         test1.add("a", "b");
         assertNotSame(test1.getMap(), test1.getMap());
 
-        final MapList<String, String> test2 = new MapList<String, String>(test1);
+        final MapList<String, String> test2 = new MapList<>(test1);
         assertEquals(test1.getMap(), test2.getMap());
     }
 

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

 
     @Before
     public void setup() {
-        list = new LinkedList<String>();
-        obslist = new ObservableListDecorator<String>(list);
+        list = new LinkedList<>();
+        obslist = new ObservableListDecorator<>(list);
         observer = mock(ListObserver.class);
         obslist.addListListener(observer);
     }

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

 
     @Test
     public void testIsEmpty() {
-        final RollingList<String> rl = new RollingList<String>(1);
+        final RollingList<String> rl = new RollingList<>(1);
         assertTrue(rl.isEmpty());
         assertTrue(rl.getList().isEmpty());
         
     
     @Test
     public void testRolling() {
-        final RollingList<String> rl = new RollingList<String>(1);
+        final RollingList<String> rl = new RollingList<>(1);
         
         rl.add("Foo");
         rl.add("Bar");
     
     @Test
     public void testClear() {
-        final RollingList<String> rl = new RollingList<String>(3);
+        final RollingList<String> rl = new RollingList<>(3);
         
         rl.add("Foo");
         rl.add("Bar");
     
     @Test
     public void testPositions() {
-        final RollingList<String> rl = new RollingList<String>(3);
+        final RollingList<String> rl = new RollingList<>(3);
         
         rl.add("Foo");
         rl.add("Bar");
 
     @Test
     public void testSetPosition() {
-        final RollingList<String> rl = new RollingList<String>(3);
+        final RollingList<String> rl = new RollingList<>(3);
 
         rl.add("Foo");
         rl.add("Bar");
     
     @Test
     public void testPrevNext() {
-        final RollingList<String> rl = new RollingList<String>(3);
+        final RollingList<String> rl = new RollingList<>(3);
         
         rl.add("Foo");
         rl.add("Bar");
     
     @Test
     public void testEmpty() {
-        final RollingList<String> rl = new RollingList<String>(1, "Meep");
+        final RollingList<String> rl = new RollingList<>(1, "Meep");
         rl.add("Foo");
         
         assertEquals("Meep", rl.getNext());

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

 
     @Test
     public void testIsEmpty() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         assertTrue(instance.isEmpty());
         instance.add("test1");
         assertFalse(instance.isEmpty());
 
     @Test
     public void testAdd() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         assertTrue(instance.add("test1"));
         assertFalse(instance.isEmpty());
     }
 
     @Test
     public void testAdd_Int() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<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<String>();
+        final WeakList<String> instance = new WeakList<>();
         instance.add("test1");
         assertFalse(instance.isEmpty());
         assertTrue(instance.remove("test1"));
 
     @Test
     public void testRemove_Int() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         assertTrue(instance.isEmpty());
         instance.add("test1");
         instance.add("test2");
 
     @Test
     public void testGet() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<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<String>();
+        final WeakList<String> instance = new WeakList<>();
         assertFalse(instance.contains("test1"));
         instance.add("test1");
         assertTrue(instance.contains("test1"));
      */
     @Test
     public void testToArray_0args() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         assertEquals(0, instance.toArray().length);
         instance.add("test1");
         instance.add("test2");
      */
     @Test
     public void testToArray_GenericType() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         assertEquals(0, instance.toArray(new String[0]).length);
         instance.add("test1");
         instance.add("test2");
      */
     @Test
     public void testContainsAllAddAll() {
-        final List<String> list = new ArrayList<String>();
+        final List<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         assertFalse(instance.containsAll(list));
         instance.addAll(list);
         assertTrue(instance.contains("test1"));
 
     @Test
     public void testAddAll_int_Collection() {
-        final List<String> list = new ArrayList<String>();
+        final List<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         instance.add("test3");
         System.out.println(instance);
         assertEquals("test3", instance.get(0));
     public void testIndexOf() {
         final String one = "test1";
         final String two = "test2";
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         instance.add(one);
         instance.add(two);
         assertEquals(2, instance.size());
     public void testLastIndexOf() {
         final String one = "test1";
         final String two = "test2";
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         instance.add(one);
         instance.add(two);
         instance.add(one);
 
     @Test
     public void testRemoveAll() {
-        final List<String> list = new ArrayList<String>();
+        final List<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         instance.addAll(list);
         assertFalse(instance.isEmpty());
         instance.removeAll(list);
 
     @Test
     public void testRetainAll() {
-        final List<String> list = new ArrayList<String>();
+        final List<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         instance.addAll(list);
         instance.add("test3");
         instance.add("test4");
 
     @Test
     public void testClear() {
-        final List<String> list = new ArrayList<String>();
+        final List<String> list = new ArrayList<>();
         list.add("test1");
         list.add("test2");
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         instance.addAll(list);
         assertFalse(instance.isEmpty());
         instance.clear();
 
     @Test
     public void testSet() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<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<String>();
+        final WeakList<String> instance = new WeakList<>();
         Iterator result = instance.iterator();
         assertFalse(result.hasNext());
         instance.add("test1");
 
     @Test
     public void testListIterator_0args() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<String> instance = new WeakList<>();
         ListIterator result = instance.listIterator();
         assertFalse(result.hasNext());
         instance.add("test1");
 
     @Test(expected=IndexOutOfBoundsException.class)
     public void testListIterator_int() {
-        final WeakList<String> instance = new WeakList<String>();
+        final WeakList<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<String>();
+        final WeakList<String> instance = new WeakList<>();
         instance.add("test1");
         instance.add("test2");
         instance.add("test3");

test/com/dmdirc/util/io/ConfigFileTest.java

     public void testColons() throws IOException, InvalidConfigFileException {
         final File file = File.createTempFile("DMDirc.unittest", null);
         ConfigFile config = new ConfigFile(file);
-        Map<String, String> data = new HashMap<String, String>();
+        Map<String, String> data = new HashMap<>();
         data.put("test1", "hello");
         data.put("test:2", "hello");
         data.put("test3", "hello:");
     public void testEquals() throws IOException, InvalidConfigFileException {
         final File file = File.createTempFile("DMDirc.unittest", null);
         ConfigFile config = new ConfigFile(file);
-        Map<String, String> data = new HashMap<String, String>();
+        Map<String, String> data = new HashMap<>();
         data.put("test1", "hello");
         data.put("test=2", "hello");
         data.put("test3", "hello=");
     public void testNewlines() throws IOException, InvalidConfigFileException {
         final File file = File.createTempFile("DMDirc.unittest", null);
         ConfigFile config = new ConfigFile(file);
-        Map<String, String> data = new HashMap<String, String>();
+        Map<String, String> data = new HashMap<>();
         data.put("test1", "hello");
         data.put("test2", "hello\ngoodbye");
         data.put("test3", "hello\n");
     public void testBackslash() throws IOException, InvalidConfigFileException {
         final File file = File.createTempFile("DMDirc.unittest", null);
         ConfigFile config = new ConfigFile(file);
-        Map<String, String> data = new HashMap<String, String>();
+        Map<String, String> data = new HashMap<>();
         data.put("test1", "hello\\");
         data.put("test2", "\\nhello");
         data.put("test3\\", "hello");
     public void testHash() throws IOException, InvalidConfigFileException {
         final File file = File.createTempFile("DMDirc.unittest", null);
         ConfigFile config = new ConfigFile(file);
-        Map<String, String> data = new HashMap<String, String>();
+        Map<String, String> data = new HashMap<>();
         data.put("test1#", "hello");
         data.put("#test2", "hello");
         data.put("test3", "#hello");

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

 
     @Test
     public void testGetValidator() {
-        final Validator<String> validator = new PermissiveValidator<String>();
+        final Validator<String> validator = new PermissiveValidator<>();
         final OptionalValidator instance = new OptionalValidator(validator);
         assertEquals(validator, instance.getValidator());
     }

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

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