    @Test
    public void testExcludeFilterExpansion() throws ParseException {
        parser = new JexlControlledQueryParser();
        Set<String> allowedFields = new HashSet<>();
        allowedFields.add("1337_1");
        allowedFields.add("9001_1");
        parser.setAllowedFields(allowedFields);

        Map<String,Set<String>> excludedValMap = new HashMap<>();
        Set<String> excludedValSet = new HashSet<>();
        excludedValSet.add("John");
        excludedValSet.add("Doe");
        excludedValMap.put("$1337_1", excludedValSet);
        parser.setExcludedValues(excludedValMap);

        String expandedQuery = parser.parse("$9001_1='dudududuu'").getOriginalQuery();

        // Note: Or clause is not order dependent and may flip between jvm impls / versions.
        Assert.assertTrue("($9001_1='dudududuu') && ((not(filter:includeRegex($1337_1, 'Doe')) && not(filter:includeRegex($1337_1, 'John'))))"
                        .equals(expandedQuery)
                        || "($9001_1='dudududuu') && ((not(filter:includeRegex($1337_1, 'John')) && not(filter:includeRegex($1337_1, 'Doe'))))"
                                        .equals(expandedQuery));
    }

    @Test
    public void testExcludeFilterExpansion() throws ParseException {
        parser = new JexlControlledQueryParser();
        Set<String> allowedFields = new HashSet<>();
        allowedFields.add("1337_1");
        allowedFields.add("9001_1");
        parser.setAllowedFields(allowedFields);

        Map<String,Set<String>> excludedValMap = new HashMap<String,Set<String>>();
        Set<String> excludedValSet = new HashSet<>();
        excludedValSet.add("John");
        excludedValSet.add("Doe");
        excludedValMap.put("$1337_1", excludedValSet);
        parser.setExcludedValues(excludedValMap);

        String expandedQuery = parser.parse("$9001_1='dudududuu'").getOriginalQuery();

        // Note: Or clause is not order dependent and may flip between jvm impls / versions.
        Assert.assertTrue("($9001_1='dudududuu') && ((not(filter:includeRegex($1337_1, 'Doe')) && not(filter:includeRegex($1337_1, 'John'))))"
                        .equals(expandedQuery)
                        || "($9001_1='dudududuu') && ((not(filter:includeRegex($1337_1, 'John')) && not(filter:includeRegex($1337_1, 'Doe'))))"
                                        .equals(expandedQuery));
    }

Replace Generic With Diamond HashMap<String,Set<String>> with HashMap<> in method public testExcludeFilterExpansion() : void from class datawave.query.language.parser.jexl.JexlControlledQueryParserTest


    @BeforeClass
    public static void setupClass() throws Exception {
        System.setProperty("subject.dn.pattern", "(?:^|,)\\s*OU\\s*=\\s*My Department\\s*(?:,|$)");

        setupConfiguration(conf);

        AbstractColumnBasedHandler<Text> dataTypeHandler = new AbstractColumnBasedHandler<>();
        dataTypeHandler.setup(new TaskAttemptContextImpl(conf, new TaskAttemptID()));

        TestIngestHelper ingestHelper = new TestIngestHelper();
        ingestHelper.setup(conf);

        // create and process events with WKT data
        RawRecordContainer record = new RawRecordContainerImpl();
        Multimap<BulkIngestKey,Value> keyValues = HashMultimap.create();
        int recNum = 1;
        for (int dataIdx = 0; dataIdx < 2; dataIdx++) {

            String beginDate;
            String[] wktData;
            Integer[] wktByteLengthData;
            long[] dates;
            boolean useCompositeIngest;

            if (dataIdx == 0) {
                beginDate = LEGACY_BEGIN_DATE;
                wktData = wktLegacyData;
                wktByteLengthData = wktByteLengthLegacyData;
                dates = legacyDates;
                useCompositeIngest = false;
            } else {
                beginDate = COMPOSITE_BEGIN_DATE;
                wktData = wktCompositeData;
                wktByteLengthData = wktByteLengthCompositeData;
                dates = compositeDates;
                useCompositeIngest = true;
            }

            for (int i = 0; i < wktData.length; i++) {
                record.clear();
                record.setDataType(new Type(DATA_TYPE_NAME, TestIngestHelper.class, (Class) null, (String[]) null, 1, (String[]) null));
                record.setRawFileName("geodata_" + recNum + ".dat");
                record.setRawRecordNumber(recNum++);
                record.setDate(formatter.parse(beginDate).getTime() + dates[i]);
                record.setRawData((wktData[i] + "|" + ((wktByteLengthData[i] != null) ? Integer.toString(wktByteLengthData[i]) : "")).getBytes("UTF8"));
                record.generateId(null);
                record.setVisibility(new ColumnVisibility(AUTHS));

                final Multimap<String,NormalizedContentInterface> fields = ingestHelper.getEventFields(record);

                if (useCompositeIngest && ingestHelper instanceof CompositeIngest) {
                    Multimap<String,NormalizedContentInterface> compositeFields = ingestHelper.getCompositeFields(fields);
                    for (String fieldName : compositeFields.keySet()) {
                        // if this is an overloaded event field, we are replacing the existing data
                        if (ingestHelper.isOverloadedCompositeField(fieldName))
                            fields.removeAll(fieldName);
                        fields.putAll(fieldName, compositeFields.get(fieldName));
                    }
                }

                Multimap kvPairs = dataTypeHandler.processBulk(new Text(), record, fields, new MockStatusReporter());

                keyValues.putAll(kvPairs);

                dataTypeHandler.getMetadata().addEvent(ingestHelper, record, fields);
            }
        }
        keyValues.putAll(dataTypeHandler.getMetadata().getBulkMetadata());

        // write these values to their respective tables
        instance = new InMemoryInstance();
        Connector connector = instance.getConnector("root", PASSWORD);
        connector.securityOperations().changeUserAuthorizations("root", new Authorizations(AUTHS));

        writeKeyValues(connector, keyValues);
    }

    @BeforeClass
    public static void setupClass() throws Exception {
        System.setProperty("subject.dn.pattern", "(?:^|,)\\s*OU\\s*=\\s*My Department\\s*(?:,|$)");

        setupConfiguration(conf);

        AbstractColumnBasedHandler<Text> dataTypeHandler = new AbstractColumnBasedHandler<Text>();
        dataTypeHandler.setup(new TaskAttemptContextImpl(conf, new TaskAttemptID()));

        TestIngestHelper ingestHelper = new TestIngestHelper();
        ingestHelper.setup(conf);

        // create and process events with WKT data
        RawRecordContainer record = new RawRecordContainerImpl();
        Multimap<BulkIngestKey,Value> keyValues = HashMultimap.create();
        int recNum = 1;
        for (int dataIdx = 0; dataIdx < 2; dataIdx++) {

            String beginDate;
            String[] wktData;
            Integer[] wktByteLengthData;
            long[] dates;
            boolean useCompositeIngest;

            if (dataIdx == 0) {
                beginDate = LEGACY_BEGIN_DATE;
                wktData = wktLegacyData;
                wktByteLengthData = wktByteLengthLegacyData;
                dates = legacyDates;
                useCompositeIngest = false;
            } else {
                beginDate = COMPOSITE_BEGIN_DATE;
                wktData = wktCompositeData;
                wktByteLengthData = wktByteLengthCompositeData;
                dates = compositeDates;
                useCompositeIngest = true;
            }

            for (int i = 0; i < wktData.length; i++) {
                record.clear();
                record.setDataType(new Type(DATA_TYPE_NAME, TestIngestHelper.class, (Class) null, (String[]) null, 1, (String[]) null));
                record.setRawFileName("geodata_" + recNum + ".dat");
                record.setRawRecordNumber(recNum++);
                record.setDate(formatter.parse(beginDate).getTime() + dates[i]);
                record.setRawData((wktData[i] + "|" + ((wktByteLengthData[i] != null) ? Integer.toString(wktByteLengthData[i]) : "")).getBytes("UTF8"));
                record.generateId(null);
                record.setVisibility(new ColumnVisibility(AUTHS));

                final Multimap<String,NormalizedContentInterface> fields = ingestHelper.getEventFields(record);

                if (useCompositeIngest && ingestHelper instanceof CompositeIngest) {
                    Multimap<String,NormalizedContentInterface> compositeFields = ingestHelper.getCompositeFields(fields);
                    for (String fieldName : compositeFields.keySet()) {
                        // if this is an overloaded event field, we are replacing the existing data
                        if (ingestHelper.isOverloadedCompositeField(fieldName))
                            fields.removeAll(fieldName);
                        fields.putAll(fieldName, compositeFields.get(fieldName));
                    }
                }

                Multimap kvPairs = dataTypeHandler.processBulk(new Text(), record, fields, new MockStatusReporter());

                keyValues.putAll(kvPairs);

                dataTypeHandler.getMetadata().addEvent(ingestHelper, record, fields);
            }
        }
        keyValues.putAll(dataTypeHandler.getMetadata().getBulkMetadata());

        // write these values to their respective tables
        instance = new InMemoryInstance();
        Connector connector = instance.getConnector("root", PASSWORD);
        connector.securityOperations().changeUserAuthorizations("root", new Authorizations(AUTHS));

        writeKeyValues(connector, keyValues);
    }

Replace Generic With Diamond AbstractColumnBasedHandler<Text> with AbstractColumnBasedHandler<> in method public setupClass() : void from class datawave.query.planner.CompositeIndexTest


    @BeforeClass
    public static void setupClass() throws Exception {
        setupEnvVariables();
        conf.addResource(ClassLoader.getSystemResource("datawave/query/tables/geo-test-config.xml"));
        resolveEnvVariables(conf);

        TypeRegistry.reset();
        TypeRegistry registry = TypeRegistry.getInstance(conf);

        TaskAttemptContext ctx = new TaskAttemptContextImpl(conf, new TaskAttemptID());

        AbstractColumnBasedHandler<Text> dataTypeHandler = new AbstractColumnBasedHandler<>();
        dataTypeHandler.setup(ctx);

        TestIngestHelper ingestHelper = (TestIngestHelper) dataTypeHandler.getHelper(registry.get(DATA_TYPE_NAME));

        // create and process events with WKT data
        RawRecordContainer record = new RawRecordContainerImpl();
        Multimap<BulkIngestKey,Value> keyValues = HashMultimap.create();
        int recNum = 1;
        for (int i = 0; i < wktData.length; i++) {
            record.clear();
            record.setDataType(new Type(DATA_TYPE_NAME, TestIngestHelper.class, (Class) null, (String[]) null, 1, (String[]) null));
            record.setRawFileName("geodata_" + recNum + ".dat");
            record.setRawRecordNumber(recNum++);
            record.setDate(formatter.parse(BEGIN_DATE).getTime() + dates[i]);
            record.setRawData(wktData[i].getBytes("UTF8"));
            record.generateId(null);
            record.setVisibility(new ColumnVisibility(AUTHS));

            final Multimap<String,NormalizedContentInterface> fields = ingestHelper.getEventFields(record);

            Multimap kvPairs = dataTypeHandler.processBulk(new Text(), record, fields, new MockStatusReporter());

            keyValues.putAll(kvPairs);

            dataTypeHandler.getMetadata().addEvent(ingestHelper, record, fields);
        }

        keyValues.putAll(dataTypeHandler.getMetadata().getBulkMetadata());

        // write these values to their respective tables
        instance = new InMemoryInstance();
        Connector connector = instance.getConnector("root", PASSWORD);
        connector.securityOperations().changeUserAuthorizations("root", new Authorizations(AUTHS));

        writeKeyValues(connector, keyValues);
    }

    @BeforeClass
    public static void setupClass() throws Exception {
        setupEnvVariables();
        conf.addResource(ClassLoader.getSystemResource("datawave/query/tables/geo-test-config.xml"));
        resolveEnvVariables(conf);

        TypeRegistry.reset();
        TypeRegistry registry = TypeRegistry.getInstance(conf);

        TaskAttemptContext ctx = new TaskAttemptContextImpl(conf, new TaskAttemptID());

        AbstractColumnBasedHandler<Text> dataTypeHandler = new AbstractColumnBasedHandler<Text>();
        dataTypeHandler.setup(ctx);

        TestIngestHelper ingestHelper = (TestIngestHelper) dataTypeHandler.getHelper(registry.get(DATA_TYPE_NAME));

        // create and process events with WKT data
        RawRecordContainer record = new RawRecordContainerImpl();
        Multimap<BulkIngestKey,Value> keyValues = HashMultimap.create();
        int recNum = 1;
        for (int i = 0; i < wktData.length; i++) {
            record.clear();
            record.setDataType(new Type(DATA_TYPE_NAME, TestIngestHelper.class, (Class) null, (String[]) null, 1, (String[]) null));
            record.setRawFileName("geodata_" + recNum + ".dat");
            record.setRawRecordNumber(recNum++);
            record.setDate(formatter.parse(BEGIN_DATE).getTime() + dates[i]);
            record.setRawData(wktData[i].getBytes("UTF8"));
            record.generateId(null);
            record.setVisibility(new ColumnVisibility(AUTHS));

            final Multimap<String,NormalizedContentInterface> fields = ingestHelper.getEventFields(record);

            Multimap kvPairs = dataTypeHandler.processBulk(new Text(), record, fields, new MockStatusReporter());

            keyValues.putAll(kvPairs);

            dataTypeHandler.getMetadata().addEvent(ingestHelper, record, fields);
        }

        keyValues.putAll(dataTypeHandler.getMetadata().getBulkMetadata());

        // write these values to their respective tables
        instance = new InMemoryInstance();
        Connector connector = instance.getConnector("root", PASSWORD);
        connector.securityOperations().changeUserAuthorizations("root", new Authorizations(AUTHS));

        writeKeyValues(connector, keyValues);
    }

Replace Generic With Diamond AbstractColumnBasedHandler<Text> with AbstractColumnBasedHandler<> in method public setupClass() : void from class datawave.query.planner.GeoSortedQueryDataTest


    @BeforeClass
    public static void setupClass() throws Exception {
        System.setProperty("subject.dn.pattern", "(?:^|,)\\s*OU\\s*=\\s*My Department\\s*(?:,|$)");

        createTestData();

        setupConfiguration(conf);

        AbstractColumnBasedHandler<Text> dataTypeHandler = new AbstractColumnBasedHandler<>();
        dataTypeHandler.setup(new TaskAttemptContextImpl(conf, new TaskAttemptID()));

        TestIngestHelper ingestHelper = new TestIngestHelper();
        ingestHelper.setup(conf);

        // create and process events with WKT data
        RawRecordContainer record = new RawRecordContainerImpl();
        Multimap<BulkIngestKey,Value> keyValues = HashMultimap.create();
        int recNum = 1;

        for (int i = 0; i < testData.size(); i++) {
            TestData entry = testData.get(i);

            record.clear();
            record.setDataType(new Type(DATA_TYPE_NAME, TestIngestHelper.class, (Class) null, (String[]) null, 1, (String[]) null));
            record.setRawFileName("geodata_" + recNum + ".dat");
            record.setRawRecordNumber(recNum++);
            record.setDate(formatter.parse(COMPOSITE_BEGIN_DATE).getTime());
            record.setRawData(entry.toString().getBytes("UTF8"));
            record.generateId(null);
            record.setVisibility(new ColumnVisibility(AUTHS));

            final Multimap<String,NormalizedContentInterface> fields = ingestHelper.getEventFields(record);

            Multimap<String,NormalizedContentInterface> compositeFields = ingestHelper.getCompositeFields(fields);
            for (String fieldName : compositeFields.keySet()) {
                // if this is an overloaded event field, we are replacing the existing data
                if (ingestHelper.isOverloadedCompositeField(fieldName))
                    fields.removeAll(fieldName);
                fields.putAll(fieldName, compositeFields.get(fieldName));
            }

            Multimap kvPairs = dataTypeHandler.processBulk(new Text(), record, fields, new MockStatusReporter());

            keyValues.putAll(kvPairs);

            dataTypeHandler.getMetadata().addEvent(ingestHelper, record, fields);
        }

        keyValues.putAll(dataTypeHandler.getMetadata().getBulkMetadata());

        // write these values to their respective tables
        instance = new InMemoryInstance();
        Connector connector = instance.getConnector("root", PASSWORD);
        connector.securityOperations().changeUserAuthorizations("root", new Authorizations(AUTHS));

        writeKeyValues(connector, keyValues);
    }

    @BeforeClass
    public static void setupClass() throws Exception {
        System.setProperty("subject.dn.pattern", "(?:^|,)\\s*OU\\s*=\\s*My Department\\s*(?:,|$)");

        createTestData();

        setupConfiguration(conf);

        AbstractColumnBasedHandler<Text> dataTypeHandler = new AbstractColumnBasedHandler<Text>();
        dataTypeHandler.setup(new TaskAttemptContextImpl(conf, new TaskAttemptID()));

        TestIngestHelper ingestHelper = new TestIngestHelper();
        ingestHelper.setup(conf);

        // create and process events with WKT data
        RawRecordContainer record = new RawRecordContainerImpl();
        Multimap<BulkIngestKey,Value> keyValues = HashMultimap.create();
        int recNum = 1;

        for (int i = 0; i < testData.size(); i++) {
            TestData entry = testData.get(i);

            record.clear();
            record.setDataType(new Type(DATA_TYPE_NAME, TestIngestHelper.class, (Class) null, (String[]) null, 1, (String[]) null));
            record.setRawFileName("geodata_" + recNum + ".dat");
            record.setRawRecordNumber(recNum++);
            record.setDate(formatter.parse(COMPOSITE_BEGIN_DATE).getTime());
            record.setRawData(entry.toString().getBytes("UTF8"));
            record.generateId(null);
            record.setVisibility(new ColumnVisibility(AUTHS));

            final Multimap<String,NormalizedContentInterface> fields = ingestHelper.getEventFields(record);

            Multimap<String,NormalizedContentInterface> compositeFields = ingestHelper.getCompositeFields(fields);
            for (String fieldName : compositeFields.keySet()) {
                // if this is an overloaded event field, we are replacing the existing data
                if (ingestHelper.isOverloadedCompositeField(fieldName))
                    fields.removeAll(fieldName);
                fields.putAll(fieldName, compositeFields.get(fieldName));
            }

            Multimap kvPairs = dataTypeHandler.processBulk(new Text(), record, fields, new MockStatusReporter());

            keyValues.putAll(kvPairs);

            dataTypeHandler.getMetadata().addEvent(ingestHelper, record, fields);
        }

        keyValues.putAll(dataTypeHandler.getMetadata().getBulkMetadata());

        // write these values to their respective tables
        instance = new InMemoryInstance();
        Connector connector = instance.getConnector("root", PASSWORD);
        connector.securityOperations().changeUserAuthorizations("root", new Authorizations(AUTHS));

        writeKeyValues(connector, keyValues);
    }

Replace Generic With Diamond AbstractColumnBasedHandler<Text> with AbstractColumnBasedHandler<> in method public setupClass() : void from class datawave.query.planner.MultiValueCompositeIndexTest


    @Test
    public void testMetrics() {
        SimpleUDPServer server = null;
        server = new SimpleUDPServer(9875);
        server.start();

        // create a client
        QueryStatsDClient client = new QueryStatsDClient("queryid", "localhost", server.getPort(), 50);

        // send some metrics
        client.seek();
        client.next();
        client.next();
        client.addSource();
        client.addSource();
        client.addSource();
        client.timing("MyMethod", 4242);
        client.flush();

        // wait at least 200 ms to ensure the data is received
        sleep(1000);

        // verify the sent metrics
        Set<String> messages = new HashSet<>(server.getMessages());
        System.out.println(messages);
        Assert.assertFalse("Did not receive messages", messages.isEmpty());
        Assert.assertEquals("Did not receive 4 messages", 4, messages.size());
        Assert.assertTrue("Did not receive correct seek message", messages.contains("queryid.dwquery.seek_calls:1|c"));
        Assert.assertTrue("Did not receive correct next message", messages.contains("queryid.dwquery.next_calls:2|c"));
        Assert.assertTrue("Did not receive correct sources message", messages.contains("queryid.dwquery.sources:3|c"));
        Assert.assertTrue("Did not receive correct timing message", messages.contains("queryid.dwquery.MyMethod:4242|c"));

        client.stop();
        server.stop();
    }

    @Test
    public void testMetrics() {
        SimpleUDPServer server = null;
        server = new SimpleUDPServer(9875);
        server.start();

        // create a client
        QueryStatsDClient client = new QueryStatsDClient("queryid", "localhost", server.getPort(), 50);

        // send some metrics
        client.seek();
        client.next();
        client.next();
        client.addSource();
        client.addSource();
        client.addSource();
        client.timing("MyMethod", 4242);
        client.flush();

        // wait at least 200 ms to ensure the data is received
        sleep(1000);

        // verify the sent metrics
        Set<String> messages = new HashSet<String>(server.getMessages());
        System.out.println(messages);
        Assert.assertFalse("Did not receive messages", messages.isEmpty());
        Assert.assertEquals("Did not receive 4 messages", 4, messages.size());
        Assert.assertTrue("Did not receive correct seek message", messages.contains("queryid.dwquery.seek_calls:1|c"));
        Assert.assertTrue("Did not receive correct next message", messages.contains("queryid.dwquery.next_calls:2|c"));
        Assert.assertTrue("Did not receive correct sources message", messages.contains("queryid.dwquery.sources:3|c"));
        Assert.assertTrue("Did not receive correct timing message", messages.contains("queryid.dwquery.MyMethod:4242|c"));

        client.stop();
        server.stop();
    }

Replace Generic With Diamond HashSet<String> with HashSet<> in method public testMetrics() : void from class datawave.query.statsd.QueryStatsdDClientTest


    @Test
    public void testMultipleQueryMetrics() {
        SimpleUDPServer server = null;
        server = new SimpleUDPServer(9876);
        server.start();

        // create a client or two
        QueryStatsDClient client1 = new QueryStatsDClient("queryid1", "localhost", server.getPort(), 50);
        QueryStatsDClient client2 = new QueryStatsDClient("queryid2", "localhost", server.getPort(), 50);

        // send some metrics
        client1.seek();
        client2.seek();
        client2.seek();
        client1.next();
        client1.next();
        client2.next();
        client1.addSource();
        client1.addSource();
        client1.addSource();
        client2.addSource();
        client1.timing("MyMethod", 4242);
        client2.timing("MyMethod", 4243);
        client1.flush();
        client2.flush();

        // wait at least 200 ms to ensure the data is received
        sleep(1000);

        // verify the sent metrics
        Set<String> messages = new HashSet<>(server.getMessages());
        System.out.println(messages);
        Assert.assertFalse("Did not receive messages", messages.isEmpty());
        Assert.assertEquals("Did not receive 8 messages", 8, messages.size());

        Assert.assertTrue("Did not receive correct seek message", messages.contains("queryid1.dwquery.seek_calls:1|c"));
        Assert.assertTrue("Did not receive correct next message", messages.contains("queryid1.dwquery.next_calls:2|c"));
        Assert.assertTrue("Did not receive correct sources message", messages.contains("queryid1.dwquery.sources:3|c"));
        Assert.assertTrue("Did not receive correct timing message", messages.contains("queryid1.dwquery.MyMethod:4242|c"));

        Assert.assertTrue("Did not receive correct seek message", messages.contains("queryid2.dwquery.seek_calls:2|c"));
        Assert.assertTrue("Did not receive correct next message", messages.contains("queryid2.dwquery.next_calls:1|c"));
        Assert.assertTrue("Did not receive correct sources message", messages.contains("queryid2.dwquery.sources:1|c"));
        Assert.assertTrue("Did not receive correct timing message", messages.contains("queryid2.dwquery.MyMethod:4243|c"));

        client1.stop();
        client2.stop();
        server.stop();
    }

    @Test
    public void testMultipleQueryMetrics() {
        SimpleUDPServer server = null;
        server = new SimpleUDPServer(9876);
        server.start();

        // create a client or two
        QueryStatsDClient client1 = new QueryStatsDClient("queryid1", "localhost", server.getPort(), 50);
        QueryStatsDClient client2 = new QueryStatsDClient("queryid2", "localhost", server.getPort(), 50);

        // send some metrics
        client1.seek();
        client2.seek();
        client2.seek();
        client1.next();
        client1.next();
        client2.next();
        client1.addSource();
        client1.addSource();
        client1.addSource();
        client2.addSource();
        client1.timing("MyMethod", 4242);
        client2.timing("MyMethod", 4243);
        client1.flush();
        client2.flush();

        // wait at least 200 ms to ensure the data is received
        sleep(1000);

        // verify the sent metrics
        Set<String> messages = new HashSet<String>(server.getMessages());
        System.out.println(messages);
        Assert.assertFalse("Did not receive messages", messages.isEmpty());
        Assert.assertEquals("Did not receive 8 messages", 8, messages.size());

        Assert.assertTrue("Did not receive correct seek message", messages.contains("queryid1.dwquery.seek_calls:1|c"));
        Assert.assertTrue("Did not receive correct next message", messages.contains("queryid1.dwquery.next_calls:2|c"));
        Assert.assertTrue("Did not receive correct sources message", messages.contains("queryid1.dwquery.sources:3|c"));
        Assert.assertTrue("Did not receive correct timing message", messages.contains("queryid1.dwquery.MyMethod:4242|c"));

        Assert.assertTrue("Did not receive correct seek message", messages.contains("queryid2.dwquery.seek_calls:2|c"));
        Assert.assertTrue("Did not receive correct next message", messages.contains("queryid2.dwquery.next_calls:1|c"));
        Assert.assertTrue("Did not receive correct sources message", messages.contains("queryid2.dwquery.sources:1|c"));
        Assert.assertTrue("Did not receive correct timing message", messages.contains("queryid2.dwquery.MyMethod:4243|c"));

        client1.stop();
        client2.stop();
        server.stop();
    }

Replace Generic With Diamond HashSet<String> with HashSet<> in method public testMultipleQueryMetrics() : void from class datawave.query.statsd.QueryStatsdDClientTest


    public QueryImpl configQuery(String query, Set<Authorizations> auths) throws ParseException {
        Date startDate = simpleFormat.parse("20140701");
        Date endDate = simpleFormat.parse("20150730");
        Map<String,String> extraParams = new HashMap<>();
        QueryImpl q = new QueryImpl();
        q.setBeginDate(startDate);
        q.setEndDate(endDate);
        q.setQuery(query);
        q.setParameters(extraParams);
        q.setId(UUID.randomUUID());
        q.setPagesize(Integer.MAX_VALUE);
        q.setQueryAuthorizations(serializeAuths(auths));
        q.addParameter("model.name", "something");
        return q;
    }

    public QueryImpl configQuery(String query, Set<Authorizations> auths) throws ParseException {
        Date startDate = simpleFormat.parse("20140701");
        Date endDate = simpleFormat.parse("20150730");
        Map<String,String> extraParams = new HashMap<String,String>();
        QueryImpl q = new QueryImpl();
        q.setBeginDate(startDate);
        q.setEndDate(endDate);
        q.setQuery(query);
        q.setParameters(extraParams);
        q.setId(UUID.randomUUID());
        q.setPagesize(Integer.MAX_VALUE);
        q.setQueryAuthorizations(serializeAuths(auths));
        q.addParameter("model.name", "something");
        return q;
    }

Replace Generic With Diamond HashMap<String,String> with HashMap<> in method public configQuery(query String, auths Set<Authorizations>) : QueryImpl from class datawave.query.tables.edge.BaseEdgeQueryTest


    public static List<TestEdge> createEdges() {
        Date date = new Date();
        long timestamp = date.getTime();
        ArrayList<TestEdge> retVal = new ArrayList<>();
        retVal.add(createEdge("SUN", "MERCURY", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("EARTH", "MOON", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("CERES", "JUPITER", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("ASTEROID_BELT", "CERES", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("ASTEROID_BELT", "JUPITER", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("ASTEROID_BELT", "MARS", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("MARS", "CERES", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("HAUMEA", "NAMAKA", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("PLUTO", "CHARON", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "NEW_HORIZONS", "NEW_HORIZONS", "C", timestamp));
        retVal.add(createEdge("ERIS", "DYSNOMIA", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));

        retVal.add(createEdge("MERCURY", "VENUS", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("VENUS", "EARTH", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("EARTH", "MARS", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("MARS", "JUPITER", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("JUPITER", "SATURN", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("SATURN", "NEPTUNE", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("NEPTUNE", "PLUTO", "20150713", "AdjacentPlanets", "FROM", "TO", "NEW_HORIZONS", "NEW_HORIZONS", "C", timestamp));

        retVal.add(createEdge("PLUTO", "NEPTUNE", "20150713", "AdjacentDwarfPlanets", "FROM", "TO", "NEW_HORIZONS", "NEW_HORIZONS", "C", timestamp));
        retVal.add(createEdge("CERES", "MARS", "20150713", "AdjacentDwarfPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("CERES", "JUPITER", "20150713", "AdjacentDwarfPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));

        // Stats edges
        retVal.add(createEdge("SUN", "20150713", "ACTIVITY", "Stars", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("MERCURY", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("VENUS", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("EARTH", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("MARS", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("JUPITER", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("SATURN", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("URANUS", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("NEPTUNE", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("PLUTO", "20150713", "ACTIVITY", "DwarfPlanets", "TO", "NEW_HORIZONS", "NEW_HORIZONS", "D", timestamp));
        retVal.add(createEdge("CERES", "20150713", "ACTIVITY", "DwarfPlanets", "TO", "COSMOS_DATA", "COSMOS_DATA", "D", timestamp));
        retVal.add(createEdge("ERIS", "20150713", "ACTIVITY", "DwarfPlanets", "TO", "COSMOS_DATA", "COSMOS_DATA", "D", timestamp));

        return retVal;
    }

    public static List<TestEdge> createEdges() {
        Date date = new Date();
        long timestamp = date.getTime();
        ArrayList<TestEdge> retVal = new ArrayList<TestEdge>();
        retVal.add(createEdge("SUN", "MERCURY", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("EARTH", "MOON", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("CERES", "JUPITER", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("ASTEROID_BELT", "CERES", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("ASTEROID_BELT", "JUPITER", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("ASTEROID_BELT", "MARS", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("MARS", "CERES", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("HAUMEA", "NAMAKA", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("PLUTO", "CHARON", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "NEW_HORIZONS", "NEW_HORIZONS", "C", timestamp));
        retVal.add(createEdge("ERIS", "DYSNOMIA", "20150713", "AdjacentCelestialBodies", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));

        retVal.add(createEdge("MERCURY", "VENUS", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("VENUS", "EARTH", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("EARTH", "MARS", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("MARS", "JUPITER", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("JUPITER", "SATURN", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("SATURN", "NEPTUNE", "20150713", "AdjacentPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("NEPTUNE", "PLUTO", "20150713", "AdjacentPlanets", "FROM", "TO", "NEW_HORIZONS", "NEW_HORIZONS", "C", timestamp));

        retVal.add(createEdge("PLUTO", "NEPTUNE", "20150713", "AdjacentDwarfPlanets", "FROM", "TO", "NEW_HORIZONS", "NEW_HORIZONS", "C", timestamp));
        retVal.add(createEdge("CERES", "MARS", "20150713", "AdjacentDwarfPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("CERES", "JUPITER", "20150713", "AdjacentDwarfPlanets", "FROM", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));

        // Stats edges
        retVal.add(createEdge("SUN", "20150713", "ACTIVITY", "Stars", "TO", "COSMOS_DATA", "COSMOS_DATA", "A", timestamp));
        retVal.add(createEdge("MERCURY", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("VENUS", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("EARTH", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("MARS", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("JUPITER", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("SATURN", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("URANUS", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("NEPTUNE", "20150713", "ACTIVITY", "Planets", "TO", "COSMOS_DATA", "COSMOS_DATA", "B", timestamp));
        retVal.add(createEdge("PLUTO", "20150713", "ACTIVITY", "DwarfPlanets", "TO", "NEW_HORIZONS", "NEW_HORIZONS", "D", timestamp));
        retVal.add(createEdge("CERES", "20150713", "ACTIVITY", "DwarfPlanets", "TO", "COSMOS_DATA", "COSMOS_DATA", "D", timestamp));
        retVal.add(createEdge("ERIS", "20150713", "ACTIVITY", "DwarfPlanets", "TO", "COSMOS_DATA", "COSMOS_DATA", "D", timestamp));

        return retVal;
    }

Replace Generic With Diamond ArrayList<TestEdge> with ArrayList<> in method public createEdges() : List<TestEdge> from class datawave.query.tables.edge.BaseEdgeQueryTest


    public void compareResults(BaseQueryLogic<Map.Entry<Key,Value>> logic, List<String> expected) {
        int recordsFound = 0;
        List<Key> foundKeys = new ArrayList<>();
        for (Map.Entry<Key,Value> entry : logic) {
            foundKeys.add(entry.getKey());
            Key k = entry.getKey();
            System.out.println("key = " + k.toStringNoTime());
            Assert.assertTrue(UNEXPECTED_RECORD + " : " + k.toStringNoTime(), expected.contains(k.toStringNoTime()));
            recordsFound++;
        }

        Assert.assertEquals(UNEXPECTED_NUM_RECORDS, expected.size(), recordsFound);
    }

    public void compareResults(BaseQueryLogic<Map.Entry<Key,Value>> logic, List<String> expected) {
        int recordsFound = 0;
        List<Key> foundKeys = new ArrayList<Key>();
        for (Map.Entry<Key,Value> entry : logic) {
            foundKeys.add(entry.getKey());
            Key k = entry.getKey();
            System.out.println("key = " + k.toStringNoTime());
            Assert.assertTrue(UNEXPECTED_RECORD + " : " + k.toStringNoTime(), expected.contains(k.toStringNoTime()));
            recordsFound++;
        }

        Assert.assertEquals(UNEXPECTED_NUM_RECORDS, expected.size(), recordsFound);
    }

Replace Generic With Diamond ArrayList<Key> with ArrayList<> in method public compareResults(logic BaseQueryLogic<Map.Entry<Key,Value>>, expected List<String>) : void from class datawave.query.tables.edge.BaseEdgeQueryTest


    @Test
    public void testSingleQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'PLUTO')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");

        compareResults(logic, expected);
    }

    @Test
    public void testSingleQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'PLUTO')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testSingleQuery() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testSingleQueryMixedCase() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'pLUTO')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");

        compareResults(logic, expected);
    }

    @Test
    public void testSingleQueryMixedCase() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'pLUTO')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testSingleQueryMixedCase() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testSingleQueryLowerCase() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'pluto')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");

        compareResults(logic, expected);
    }

    @Test
    public void testSingleQueryLowerCase() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'pluto')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testSingleQueryLowerCase() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testSinglePatternQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'E.*')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;venus AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("eris%00;dysnomia AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");

        compareResults(logic, expected);
    }

    @Test
    public void testSinglePatternQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'E.*')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;venus AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("eris%00;dysnomia AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testSinglePatternQuery() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testANDQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'EARTH') && (SINK == 'MOON')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        compareResults(logic, expected);
    }

    @Test
    public void testANDQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'EARTH') && (SINK == 'MOON')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testANDQuery() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testANDQueryWithPatterns() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'E.*') && (SINK =~ '.*S' )", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;venus AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");
        compareResults(logic, expected);
    }

    @Test
    public void testANDQueryWithPatterns() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'E.*') && (SINK =~ '.*S' )", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;venus AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");
        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testANDQueryWithPatterns() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testORQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'EARTH' || SOURCE == 'PLUTO')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;venus AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");

        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");

        compareResults(logic, expected);
    }

    @Test
    public void testORQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'EARTH' || SOURCE == 'PLUTO')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;venus AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");

        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testORQuery() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testORQueryWithPattern() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'E.*' || SOURCE == 'PLUTO')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;venus AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");
        expected.add("eris%00;dysnomia AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");

        compareResults(logic, expected);
    }

    @Test
    public void testORQueryWithPattern() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'E.*' || SOURCE == 'PLUTO')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;venus AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto STATS/ACTIVITY/DwarfPlanets/TO:20150713/NEW_HORIZONS [D]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentPlanets/TO-FROM:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");
        expected.add("eris%00;dysnomia AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testORQueryWithPattern() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testCombinationQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'EARTH' || SOURCE == 'ASTEROID_BELT') && (SINK == 'MARS')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("asteroid_belt%00;mars AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");

        compareResults(logic, expected);
    }

    @Test
    public void testCombinationQuery() throws Exception {
        QueryImpl q = configQuery("(SOURCE == 'EARTH' || SOURCE == 'ASTEROID_BELT') && (SINK == 'MARS')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("asteroid_belt%00;mars AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testCombinationQuery() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testCombinationQueryWithPattern() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'E.*' || SOURCE == 'ASTEROID_BELT') && (SINK == 'MARS')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("asteroid_belt%00;mars AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");

        compareResults(logic, expected);
    }

    @Test
    public void testCombinationQueryWithPattern() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'E.*' || SOURCE == 'ASTEROID_BELT') && (SINK == 'MARS')", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("asteroid_belt%00;mars AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testCombinationQueryWithPattern() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testComplexQuery1() throws Exception {
        QueryImpl q = configQuery(
                        "(SOURCE == 'EARTH' || SOURCE == 'PLUTO' || SOURCE == 'MARS' || SOURCE == 'CERES' || SOURCE == 'ASTEROID_BELT') && RELATION == 'FROM-TO' && TYPE == 'AdjacentCelestialBodies'",
                        auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");

        expected.add("mars%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("ceres%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;mars AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");

        compareResults(logic, expected);
    }

    @Test
    public void testComplexQuery1() throws Exception {
        QueryImpl q = configQuery(
                        "(SOURCE == 'EARTH' || SOURCE == 'PLUTO' || SOURCE == 'MARS' || SOURCE == 'CERES' || SOURCE == 'ASTEROID_BELT') && RELATION == 'FROM-TO' && TYPE == 'AdjacentCelestialBodies'",
                        auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");

        expected.add("mars%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("ceres%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;mars AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testComplexQuery1() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testComplexQueryWithPatterns() throws Exception {

        QueryImpl q = configQuery(
                        "(SOURCE =~ 'E.*' || SOURCE == 'PLUTO' || SOURCE =~ 'M.*' || SOURCE == 'CERES' || SOURCE == 'ASTEROID_BELT') && RELATION == 'FROM-TO' && TYPE =~ 'Adjacent.*'",
                        auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("eris%00;dysnomia AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("mars%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("ceres%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("ceres%00;jupiter AdjacentDwarfPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("ceres%00;mars AdjacentDwarfPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("asteroid_belt%00;mars AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;jupiter AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");

        compareResults(logic, expected);
    }

    @Test
    public void testComplexQueryWithPatterns() throws Exception {

        QueryImpl q = configQuery(
                        "(SOURCE =~ 'E.*' || SOURCE == 'PLUTO' || SOURCE =~ 'M.*' || SOURCE == 'CERES' || SOURCE == 'ASTEROID_BELT') && RELATION == 'FROM-TO' && TYPE =~ 'Adjacent.*'",
                        auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("earth%00;moon AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("eris%00;dysnomia AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("pluto%00;charon AdjacentCelestialBodies/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("pluto%00;neptune AdjacentDwarfPlanets/FROM-TO:20150713/NEW_HORIZONS-NEW_HORIZONS [C]");
        expected.add("mars%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("ceres%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("ceres%00;jupiter AdjacentDwarfPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("ceres%00;mars AdjacentDwarfPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("asteroid_belt%00;mars AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("asteroid_belt%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;jupiter AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");

        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testComplexQueryWithPatterns() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testPatternWithType() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'M.*') && TYPE == 'AdjacentPlanets' ", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("mars%00;earth AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;jupiter AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        compareResults(logic, expected);
    }

    @Test
    public void testPatternWithType() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'M.*') && TYPE == 'AdjacentPlanets' ", auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("mars%00;earth AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;jupiter AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testPatternWithType() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testLiteralWithPatternAndRelation() throws Exception {
        QueryImpl q = configQuery(
                        "(( SOURCE == 'CERES') && ( SINK =~ 'JUP.*' ) && ( RELATION ==  'FROM-TO' || RELATION == 'TO-FROM') ) || ( (SOURCE =~ 'E.*') && (SINK == 'MARS' ) ) ",
                        auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("ceres%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("ceres%00;jupiter AdjacentDwarfPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("ceres STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");
        compareResults(logic, expected);
    }

    @Test
    public void testLiteralWithPatternAndRelation() throws Exception {
        QueryImpl q = configQuery(
                        "(( SOURCE == 'CERES') && ( SINK =~ 'JUP.*' ) && ( RELATION ==  'FROM-TO' || RELATION == 'TO-FROM') ) || ( (SOURCE =~ 'E.*') && (SINK == 'MARS' ) ) ",
                        auths);
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("ceres%00;jupiter AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("ceres%00;jupiter AdjacentDwarfPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("earth%00;mars AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("ceres STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");
        expected.add("earth STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("eris STATS/ACTIVITY/DwarfPlanets/TO:20150713/COSMOS_DATA [D]");
        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testLiteralWithPatternAndRelation() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testRegExQueryStatsOn() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'M.*')", auths);
        q.addParameter("stats", "true");
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("mars%00;jupiter AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;earth AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("mars%00;asteroid_belt AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;sun AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("moon%00;earth AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("mars%00;ceres AdjacentDwarfPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        compareResults(logic, expected);
    }

    @Test
    public void testRegExQueryStatsOn() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'M.*')", auths);
        q.addParameter("stats", "true");
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("mars%00;jupiter AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;earth AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("mars%00;asteroid_belt AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;sun AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("moon%00;earth AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("mars%00;ceres AdjacentDwarfPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testRegExQueryStatsOn() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testRegExQueryStatsOff() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'M.*')", auths);
        q.addParameter("stats", "false");
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("mars%00;jupiter AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;earth AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;asteroid_belt AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;sun AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("moon%00;earth AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("mars%00;ceres AdjacentDwarfPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        compareResults(logic, expected);
    }

    @Test
    public void testRegExQueryStatsOff() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'M.*')", auths);
        q.addParameter("stats", "false");
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("mars%00;jupiter AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;earth AdjacentPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;asteroid_belt AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;sun AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("moon%00;earth AdjacentCelestialBodies/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars%00;ceres AdjacentCelestialBodies/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        expected.add("mars%00;ceres AdjacentDwarfPlanets/TO-FROM:20150713/COSMOS_DATA-COSMOS_DATA [B]");
        compareResults(logic, expected);
    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testRegExQueryStatsOff() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    @Test
    public void testRelationStatsOn() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'M.*') && (SINK == 'VENUS') && (RELATION == 'FROM-TO' || RELATION == 'TO-FROM')", auths);
        q.addParameter("stats", "true");
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<>();
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("mercury STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        compareResults(logic, expected);

    }

    @Test
    public void testRelationStatsOn() throws Exception {
        QueryImpl q = configQuery("(SOURCE =~ 'M.*') && (SINK == 'VENUS') && (RELATION == 'FROM-TO' || RELATION == 'TO-FROM')", auths);
        q.addParameter("stats", "true");
        EdgeQueryLogic logic = runLogic(q, auths);

        List<String> expected = new ArrayList<String>();
        expected.add("mercury%00;venus AdjacentPlanets/FROM-TO:20150713/COSMOS_DATA-COSMOS_DATA [A]");
        expected.add("mars STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        expected.add("mercury STATS/ACTIVITY/Planets/TO:20150713/COSMOS_DATA [B]");
        compareResults(logic, expected);

    }

Replace Generic With Diamond ArrayList<String> with ArrayList<> in method public testRelationStatsOn() : void from class datawave.query.tables.edge.EdgeQueryFunctionalTest


    public List<Mutation> getMutations(boolean protobufEdgeFormat) {
        ArrayList<Mutation> retVal = new ArrayList<>();

        if (statsEdge) {
            Mutation mut = new Mutation(formatRow(getSource()));
            mut.put(getStatsColumnFamily(protobufEdgeFormat), getStatsColumnQualifier(protobufEdgeFormat), new ColumnVisibility(getVisibility()),
                            getTimestamp(), getValue());
            retVal.add(mut);

        } else {
            Mutation mut = new Mutation(formatRow(getSource(), getSink()));
            mut.put(getColumnFamily(false, protobufEdgeFormat), getColumnQualifier(false, protobufEdgeFormat), new ColumnVisibility(getVisibility()),
                            getTimestamp(), getValue());
            retVal.add(mut);
            if (isBidirectional()) {
                Mutation mut2 = new Mutation(formatRow(getSink(), getSource()));
                mut2.put(getColumnFamily(true, protobufEdgeFormat), getColumnQualifier(true, protobufEdgeFormat), new ColumnVisibility(getVisibility()),
                                getTimestamp(), getValue());
                retVal.add(mut2);
            }
        }

        return retVal;
    }

    public List<Mutation> getMutations(boolean protobufEdgeFormat) {
        ArrayList<Mutation> retVal = new ArrayList<Mutation>();

        if (statsEdge) {
            Mutation mut = new Mutation(formatRow(getSource()));
            mut.put(getStatsColumnFamily(protobufEdgeFormat), getStatsColumnQualifier(protobufEdgeFormat), new ColumnVisibility(getVisibility()),
                            getTimestamp(), getValue());
            retVal.add(mut);

        } else {
            Mutation mut = new Mutation(formatRow(getSource(), getSink()));
            mut.put(getColumnFamily(false, protobufEdgeFormat), getColumnQualifier(false, protobufEdgeFormat), new ColumnVisibility(getVisibility()),
                            getTimestamp(), getValue());
            retVal.add(mut);
            if (isBidirectional()) {
                Mutation mut2 = new Mutation(formatRow(getSink(), getSource()));
                mut2.put(getColumnFamily(true, protobufEdgeFormat), getColumnQualifier(true, protobufEdgeFormat), new ColumnVisibility(getVisibility()),
                                getTimestamp(), getValue());
                retVal.add(mut2);
            }
        }

        return retVal;
    }

Replace Generic With Diamond ArrayList<Mutation> with ArrayList<> in method public getMutations(protobufEdgeFormat boolean) : List<Mutation> from class datawave.query.tables.edge.TestEdge


    private int countUniqueness(List<Document> input, Set<String> fields) {
        Set<String> uniqueValues = new HashSet<>();
        for (Document d : input) {
            Multimap<String,String> values = HashMultimap.create();
            for (String docField : d.getDictionary().keySet()) {
                for (String field : fields) {
                    if (docField.equals(field) || docField.startsWith(field + '.')) {
                        Attribute a = d.get(docField);
                        if (a instanceof Attributes) {
                            for (Attribute c : ((Attributes) a).getAttributes()) {
                                values.put(field, String.valueOf(c.getData()));
                            }
                        } else {
                            values.put(field, String.valueOf(a.getData()));
                        }
                    }
                }
            }
            StringBuilder builder = new StringBuilder();
            List<String> docFields = new ArrayList<>(values.keySet());
            Collections.sort(docFields);
            for (String field : docFields) {
                List<String> docValues = new ArrayList<>(values.get(field));
                Collections.sort(docValues);
                if (builder.length() > 0) {
                    builder.append("/ ");
                }
                builder.append(field).append(':').append(Joiner.on(',').join(docValues));
            }
            uniqueValues.add(builder.toString());
        }
        return uniqueValues.size();
    }

    private int countUniqueness(List<Document> input, Set<String> fields) {
        Set<String> uniqueValues = new HashSet<String>();
        for (Document d : input) {
            Multimap<String,String> values = HashMultimap.create();
            for (String docField : d.getDictionary().keySet()) {
                for (String field : fields) {
                    if (docField.equals(field) || docField.startsWith(field + '.')) {
                        Attribute a = d.get(docField);
                        if (a instanceof Attributes) {
                            for (Attribute c : ((Attributes) a).getAttributes()) {
                                values.put(field, String.valueOf(c.getData()));
                            }
                        } else {
                            values.put(field, String.valueOf(a.getData()));
                        }
                    }
                }
            }
            StringBuilder builder = new StringBuilder();
            List<String> docFields = new ArrayList<>(values.keySet());
            Collections.sort(docFields);
            for (String field : docFields) {
                List<String> docValues = new ArrayList<>(values.get(field));
                Collections.sort(docValues);
                if (builder.length() > 0) {
                    builder.append("/ ");
                }
                builder.append(field).append(':').append(Joiner.on(',').join(docValues));
            }
            uniqueValues.add(builder.toString());
        }
        return uniqueValues.size();
    }

Replace Generic With Diamond HashSet<String> with HashSet<> in method private countUniqueness(input List<Document>, fields Set<String>) : int from class datawave.query.transformer.UniqueTransformTest


    @Before
    public void setUp() throws Exception {
        permissionsBean = new PermissionsBean();
        connectionFactory = mock(AccumuloConnectionFactory.class);
        connector = mock(Connector.class);
        securityOperations = mock(SecurityOperations.class);
        expect(connector.securityOperations()).andReturn(securityOperations);
        replay(connector);

        Field field = permissionsBean.getClass().getDeclaredField("connectionFactory");
        field.setAccessible(true);
        field.set(permissionsBean, connectionFactory);

        Map<String,String> trackingMap = new HashMap<>();
        expect(connectionFactory.getTrackingMap((StackTraceElement[]) EasyMock.anyObject())).andReturn(trackingMap);
        expect(connectionFactory.getConnection(AccumuloConnectionFactory.Priority.ADMIN, trackingMap)).andReturn(connector);
        connectionFactory.returnConnection(connector);
        replay(connectionFactory);
    }

    @Before
    public void setUp() throws Exception {
        permissionsBean = new PermissionsBean();
        connectionFactory = mock(AccumuloConnectionFactory.class);
        connector = mock(Connector.class);
        securityOperations = mock(SecurityOperations.class);
        expect(connector.securityOperations()).andReturn(securityOperations);
        replay(connector);

        Field field = permissionsBean.getClass().getDeclaredField("connectionFactory");
        field.setAccessible(true);
        field.set(permissionsBean, connectionFactory);

        Map<String,String> trackingMap = new HashMap<String,String>();
        expect(connectionFactory.getTrackingMap((StackTraceElement[]) EasyMock.anyObject())).andReturn(trackingMap);
        expect(connectionFactory.getConnection(AccumuloConnectionFactory.Priority.ADMIN, trackingMap)).andReturn(connector);
        connectionFactory.returnConnection(connector);
        replay(connectionFactory);
    }

Replace Generic With Diamond HashMap<String,String> with HashMap<> in method public setUp() : void from class datawave.webservice.operations.admin.PermissionsBeanTest


    private void setConnectionFactory(AccumuloConnectionFactory.Priority priority) throws Exception {
        Map<String,String> trackingMap = new HashMap<>();
        expect(connectionFactory.getTrackingMap((StackTraceElement[]) EasyMock.anyObject())).andReturn(trackingMap);
        expect(connectionFactory.getConnection(priority, trackingMap)).andReturn(connector);
        connectionFactory.returnConnection(connector);
        replay(connectionFactory);
    }

    private void setConnectionFactory(AccumuloConnectionFactory.Priority priority) throws Exception {
        Map<String,String> trackingMap = new HashMap<String,String>();
        expect(connectionFactory.getTrackingMap((StackTraceElement[]) EasyMock.anyObject())).andReturn(trackingMap);
        expect(connectionFactory.getConnection(priority, trackingMap)).andReturn(connector);
        connectionFactory.returnConnection(connector);
        replay(connectionFactory);
    }

Replace Generic With Diamond HashMap<String,String> with HashMap<> in method private setConnectionFactory(priority AccumuloConnectionFactory.Priority) : void from class datawave.webservice.operations.admin.TableAdminBeanTest


    @Before
    public void setUp() throws Exception {
        updateBean = new UpdateBean();
        updateBean.init();
        AccumuloConnectionFactory connectionFactory = mock(AccumuloConnectionFactory.class);
        connector = mock(Connector.class);

        Field field = updateBean.getClass().getDeclaredField("connectionFactory");
        field.setAccessible(true);
        field.set(updateBean, connectionFactory);

        Map<String,String> trackingMap = new HashMap<>();
        expect(connectionFactory.getTrackingMap((StackTraceElement[]) EasyMock.anyObject())).andReturn(trackingMap);
        expect(connectionFactory.getConnection(AccumuloConnectionFactory.Priority.ADMIN, trackingMap)).andReturn(connector);
        connectionFactory.returnConnection(connector);
        replay(connectionFactory);
    }

    @Before
    public void setUp() throws Exception {
        updateBean = new UpdateBean();
        updateBean.init();
        AccumuloConnectionFactory connectionFactory = mock(AccumuloConnectionFactory.class);
        connector = mock(Connector.class);

        Field field = updateBean.getClass().getDeclaredField("connectionFactory");
        field.setAccessible(true);
        field.set(updateBean, connectionFactory);

        Map<String,String> trackingMap = new HashMap<String,String>();
        expect(connectionFactory.getTrackingMap((StackTraceElement[]) EasyMock.anyObject())).andReturn(trackingMap);
        expect(connectionFactory.getConnection(AccumuloConnectionFactory.Priority.ADMIN, trackingMap)).andReturn(connector);
        connectionFactory.returnConnection(connector);
        replay(connectionFactory);
    }

Replace Generic With Diamond HashMap<String,String> with HashMap<> in method public setUp() : void from class datawave.webservice.operations.admin.UpdateBeanTest