PredicateTest.java

/**
 * Copyright (c) Codice Foundation
 * <p/>
 * This is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser
 * General Public License as published by the Free Software Foundation, either version 3 of the
 * License, or any later version.
 * <p/>
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
 * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details. A copy of the GNU Lesser General Public License
 * is distributed along with this program and can be found at
 * <http://www.gnu.org/licenses/lgpl.html>.
 */

package ddf.catalog.pubsub;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;

import org.apache.commons.lang.StringEscapeUtils;
import org.apache.lucene.store.Directory;
import org.geotools.filter.FilterTransformer;
import org.junit.Test;
import org.opengis.filter.Filter;
import org.osgi.service.event.Event;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.vividsolutions.jts.geom.Geometry;

import ddf.catalog.data.Metacard;
import ddf.catalog.data.impl.MetacardImpl;
import ddf.catalog.pubsub.criteria.contenttype.ContentTypeEvaluationCriteriaImpl;
import ddf.catalog.pubsub.criteria.contenttype.ContentTypeEvaluator;
import ddf.catalog.pubsub.criteria.contextual.ContextualEvaluator;
import ddf.catalog.pubsub.criteria.contextual.ContextualTokenizer;
import ddf.catalog.pubsub.criteria.geospatial.GeospatialEvaluationCriteria;
import ddf.catalog.pubsub.criteria.geospatial.GeospatialEvaluationCriteriaImpl;
import ddf.catalog.pubsub.criteria.geospatial.GeospatialEvaluator;
import ddf.catalog.pubsub.criteria.temporal.TemporalEvaluationCriteria;
import ddf.catalog.pubsub.criteria.temporal.TemporalEvaluationCriteriaImpl;
import ddf.catalog.pubsub.criteria.temporal.TemporalEvaluator;
import ddf.catalog.pubsub.internal.PubSubConstants;
import ddf.catalog.pubsub.internal.SubscriptionFilterVisitor;
import ddf.catalog.pubsub.predicate.ContentTypePredicate;
import ddf.catalog.pubsub.predicate.GeospatialPredicate;
import ddf.catalog.pubsub.predicate.Predicate;
import ddf.measure.Distance;

public class PredicateTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(PredicateTest.class);

    private static final double EQUATORIAL_RADIUS_IN_METERS = 6378137.0;

    private static final double NM_PER_DEG_LAT = 60.0;

    private static final double METERS_PER_NM = 1852.0;

    private static final String METADATA_FORMAT =
            "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n"
                    + "<Resource xmlns:gml=\"http://www.opengis.net/gml\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\r\n"
                    + "  <identifier qualifier=\"http://metadata.abc.com/mdr/ns/MDR/0.1/MDR.owl#URI\" value=\"http://www.abc.com/news/May2004/n05172004_200405174.html\"/>\r\n"
                    + "  <title classification=\"U\" ownerProducer=\"AUS GBR USA\">%s</title>\r\n"
                    + "  <creator classification=\"U\" ownerProducer=\"AUS GBR USA\">\r\n"
                    + "    <Person>\r\n" + "      <name>Donna Miffles</name>\r\n"
                    + "      <surname>Cat</surname>\r\n"
                    + "      <affiliation>American Forces Press Service</affiliation>\r\n"
                    + "    </Person>\r\n" + "  </creator>\r\n" + "  <subjectCoverage>\r\n"
                    + "    <Subject>\r\n" + "      <keyword value=\"exercise\"/>\r\n"
                    + "      <category qualifier=\"SubjectCoverageQualifier\" code=\"nitf\" label=\"nitf\"/>\r\n"
                    + "    </Subject>\r\n" + "  </subjectCoverage>\r\n"
                    + "  <security classification=\"U\" ownerProducer=\"USA\"/>\r\n"
                    + "</Resource>";

    private static final String LEADING_TERM = "%stest";

    private static final String TRAILING_TERM = "test%s";

    private static final String EMBEDDED_TERM = "test%smarker";

    private static final String EMBEDDED_TERM_REVERSED = "marker%stest";

    @Test
    public void testContentTypeEvaluation() throws IOException {

        String methodName = "testContentTypeEvaluation";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        // test input that has type1:version1 matches
        // test input that has type1:version2 doesn't match
        // TODO: tests input that has type2:version1 doesn't match
        // TODO: test input that has type1:""
        // TODO: test input that has "":""
        // TODO: test input that has "":version1
        // TODO: test UNKNOWN for entire contentType String

        MetacardImpl metacard = new MetacardImpl();
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        ContentTypePredicate ctp = new ContentTypePredicate("type1", "version1");
        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type1,version1");
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        Event testEvent = new Event("topic", properties);
        assertTrue(ctp.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type1,version2");
        Event testEvent1 = new Event("topic1", properties);
        assertFalse(ctp.matches(testEvent1));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, ",version2");
        testEvent1 = new Event("topic1", properties);
        assertFalse(ctp.matches(testEvent1));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type1,");
        testEvent1 = new Event("topic1", properties);
        assertFalse(ctp.matches(testEvent1));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);

        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, ",");
        testEvent1 = new Event("topic1", properties);
        assertFalse(ctp.matches(testEvent1));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);

        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "UNKNOWN");
        testEvent1 = new Event("topic1", properties);
        assertFalse(ctp.matches(testEvent1));

        // TODO: test input type1:version1 matches
        // TODO: test input type1:someversion matches
        // TODO: test input type2:version1 doesn't match
        ContentTypePredicate ctp2 = new ContentTypePredicate("type1", null);
        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type1,version1");
        Event testEvent2 = new Event("topic", properties);
        assertTrue(ctp2.matches(testEvent2));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);

        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type1,someversion");
        Event testEvent3 = new Event("topic", properties);
        assertTrue(ctp2.matches(testEvent3));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);

        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type2,someversion");
        Event testEvent4 = new Event("topic", properties);
        assertFalse(ctp2.matches(testEvent4));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testContentTypeEvaluationNullMetadata() throws IOException {
        String methodName = "testContentTypeEvaluationNullMetadata";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        ContentTypePredicate ctp = new ContentTypePredicate("type1", "version1");
        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type1,version1");
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        // No Contextual map added to properties containing indexed metadata

        Event testEvent = new Event("topic", properties);
        assertTrue(ctp.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testContentTypeEvaluationNullOperation() throws IOException {
        String methodName = "testContentTypeEvaluationNullOperation";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        MetacardImpl metacard = new MetacardImpl();
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        ContentTypePredicate ctp = new ContentTypePredicate("type1", "version1");
        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type1,version1");
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, null);
        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);

        Event testEvent = new Event("topic", properties);
        assertTrue(ctp.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testContentTypeFilter() throws Exception {
        String methodName = "testContentTypeFilter";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        MetacardImpl metacard = new MetacardImpl();
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        String type = "type_1";
        String version = "v1";

        List<MockTypeVersionsExtension> extensions = new ArrayList<>();
        MockTypeVersionsExtension ext1 = new MockTypeVersionsExtension();
        List<String> ext1Versions = ext1.getVersions();
        ext1Versions.add(version);
        ext1.setExtensionTypeName(type);
        extensions.add(ext1);

        MockQuery query = new MockQuery();
        query.addTypeFilter(extensions);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate pred = (Predicate) query.getFilter().accept(visitor, null);

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type + "," + version);
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        // Below Pulled from PubSubProviderImpl
        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        Event testEvent = new Event("topic", properties);
        assertTrue(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type + "," + "unmatching_version");
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "unmatchingtype" + "," + version);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY,
                "unmatchingtype" + "," + "unmatchingversion");
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    private Map<String, Object> constructContextualMap(MetacardImpl metacard) throws IOException {
        Directory index = ContextualEvaluator.buildIndex(metacard.getMetadata());
        Map<String, Object> contextualMap = new HashMap<>();
        contextualMap.put("DEFAULT_INDEX", index);
        contextualMap.put("METADATA", metacard.getMetadata());
        return contextualMap;
    }

    @Test
    public void testContentTypeFilterTypeOnly() throws Exception {
        String methodName = "testContentTypeFilterTypeOnly";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        MetacardImpl metacard = new MetacardImpl();
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        String type1 = "type_1";
        List<MockTypeVersionsExtension> extensions = new ArrayList<>();
        MockTypeVersionsExtension ext1 = new MockTypeVersionsExtension();
        ext1.setExtensionTypeName(type1);
        extensions.add(ext1);

        MockQuery query = new MockQuery();
        query.addTypeFilter(extensions);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        ContentTypePredicate pred = (ContentTypePredicate) query.getFilter().accept(visitor, null);
        assertEquals(type1, pred.getType());
        assertNull(pred.getVersion());

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        // handle null case
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, null);
        Event testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        // handle content type
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + ",");
        testEvent = new Event("topic", properties);
        assertTrue(pred.matches(testEvent));

        // handle content version that matches content type
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "," + type1);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + "random_version");
        testEvent = new Event("topic", properties);
        assertTrue(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY,
                "unmatchingtype" + "," + "random_version");
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties
                .put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "," + "unmatchingversion"); // Invalid
        // input
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testMultipleContentTypes() throws IOException {
        String methodName = "testMultipleContentTypes";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        String type1 = "type1";
        String version1 = "version1";
        String type2 = "type2";
        String version2 = "version2";
        String type3 = "type3";
        String version4 = "version4";

        MetacardImpl metacard = new MetacardImpl();
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        List<MockTypeVersionsExtension> extensions = createContentTypeVersionList(
                "type1,version1|type2,version2|type3,|,version4");

        MockQuery query = new MockQuery();
        query.addTypeFilter(extensions);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
        LOGGER.debug("Resulting Predicate: " + pred);

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + version1);
        Event testEvent = new Event("topic", properties);
        assertTrue(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type2 + "," + version2);
        testEvent = new Event("topic", properties);
        assertTrue(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type2 + "," + version1);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + version2);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type3 + "," + "random_version");
        testEvent = new Event("topic", properties);
        assertTrue(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY,
                "random_type" + "," + "random_version");
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "random_type" + "," + version4);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testContentTypesWildcard() throws IOException {
        String methodName = "testContentTypesWildcard";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        String type1 = "type1*";
        String type1Input = "type1";
        String version1 = "version1";
        String type2 = "type2";
        String version2 = "version2*";
        String version2Input = "version2abc";
        String type3 = "ty*pe3";
        String type3Input = "type3";
        String version4 = "version4";

        MetacardImpl metacard = new MetacardImpl();
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        List<MockTypeVersionsExtension> extensions = new ArrayList<>();
        MockTypeVersionsExtension ext1 = new MockTypeVersionsExtension();
        List<String> ext1Versions = ext1.getVersions();
        ext1Versions.add(version1);
        ext1.setExtensionTypeName(type1);
        extensions.add(ext1);

        MockTypeVersionsExtension ext2 = new MockTypeVersionsExtension();
        List<String> ext2Versions = ext2.getVersions();
        ext2Versions.add(version2);
        ext2.setExtensionTypeName(type2);
        extensions.add(ext2);

        // No version
        MockTypeVersionsExtension ext3 = new MockTypeVersionsExtension();
        ext3.setExtensionTypeName(type3);
        extensions.add(ext3);

        // No type, only version(s)
        MockTypeVersionsExtension ext4 = new MockTypeVersionsExtension();
        List<String> ext4Versions = ext4.getVersions();
        ext4Versions.add(version4);
        extensions.add(ext4);

        MockQuery query = new MockQuery();
        query.addTypeFilter(extensions);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
        LOGGER.debug("Resulting Predicate: " + pred);

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1Input + "," + version1);
        Event testEvent = new Event("topic", properties);
        assertTrue(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type2 + "," + version2Input);
        testEvent = new Event("topic", properties);
        assertTrue(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type2 + "," + version1);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + version2);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties
                .put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type3Input + "," + "random_version");
        testEvent = new Event("topic", properties);
        assertTrue(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY,
                "random_type" + "," + "random_version");
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "random_type" + "," + version4);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testTemporal() throws Exception {
        String methodName = "testTemporal";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        MockQuery query = new MockQuery();

        DatatypeFactory df = DatatypeFactory.newInstance();
        XMLGregorianCalendar start = df.newXMLGregorianCalendarDate(2011, 10, 25, 0);
        XMLGregorianCalendar end = df.newXMLGregorianCalendarDate(2011, 10, 27, 0);
        query.addTemporalFilter(start, end, Metacard.EFFECTIVE);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
        LOGGER.debug("resulting predicate: " + pred);

        Filter filter = query.getFilter();
        FilterTransformer transform = new FilterTransformer();
        transform.setIndentation(2);
        String filterXml = transform.transform(filter);
        LOGGER.debug(filterXml);

        // input that passes temporal
        LOGGER.debug("\npass temporal.\n");
        MetacardImpl metacard = new MetacardImpl();
        metacard.setCreatedDate(new Date());
        metacard.setExpirationDate(new Date());
        metacard.setModifiedDate(new Date());
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        XMLGregorianCalendar cal = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
        Date effectiveDate = cal.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate);

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        Event testEvent = new Event("topic", properties);
        boolean b = pred.matches(testEvent);
        assertTrue(b);

        // input that fails temporal
        LOGGER.debug("\nfail temporal.  fail content type.\n");
        XMLGregorianCalendar cal1 = df.newXMLGregorianCalendarDate(2012, 10, 30, 0); // time out of
        // range
        Date effectiveDate1 = cal1.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate1);
        LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testTemporalNullMetadata() throws Exception {
        String methodName = "testTemporalNullMetadata";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        MockQuery query = new MockQuery();

        DatatypeFactory df = DatatypeFactory.newInstance();
        XMLGregorianCalendar start = df.newXMLGregorianCalendarDate(2011, 10, 25, 0);
        XMLGregorianCalendar end = df.newXMLGregorianCalendarDate(2011, 10, 27, 0);
        query.addTemporalFilter(start, end, Metacard.EFFECTIVE);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
        LOGGER.debug("resulting predicate: " + pred);

        Filter filter = query.getFilter();
        FilterTransformer transform = new FilterTransformer();
        transform.setIndentation(2);
        String filterXml = transform.transform(filter);
        LOGGER.debug(filterXml);

        // input that passes temporal
        LOGGER.debug("\npass temporal.\n");
        MetacardImpl metacard = new MetacardImpl();
        metacard.setCreatedDate(new Date());
        metacard.setExpirationDate(new Date());
        metacard.setModifiedDate(new Date());

        XMLGregorianCalendar cal = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
        Date effectiveDate = cal.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate);

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        // no contextual map containing indexed contextual data

        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        Event testEvent = new Event("topic", properties);
        boolean b = pred.matches(testEvent);
        assertTrue(b);

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testTemporalNullOperation() throws Exception {
        String methodName = "testTemporalNullOperation";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        MockQuery query = new MockQuery();

        DatatypeFactory df = DatatypeFactory.newInstance();
        XMLGregorianCalendar start = df.newXMLGregorianCalendarDate(2011, 10, 25, 0);
        XMLGregorianCalendar end = df.newXMLGregorianCalendarDate(2011, 10, 27, 0);
        query.addTemporalFilter(start, end, Metacard.EFFECTIVE);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
        LOGGER.debug("resulting predicate: " + pred);

        Filter filter = query.getFilter();
        FilterTransformer transform = new FilterTransformer();
        transform.setIndentation(2);
        String filterXml = transform.transform(filter);
        LOGGER.debug(filterXml);

        // input that passes temporal
        LOGGER.debug("\npass temporal.\n");
        MetacardImpl metacard = new MetacardImpl();
        metacard.setCreatedDate(new Date());
        metacard.setExpirationDate(new Date());
        metacard.setModifiedDate(new Date());
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        XMLGregorianCalendar cal = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
        Date effectiveDate = cal.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate);

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, null);
        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);

        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        Event testEvent = new Event("topic", properties);
        boolean b = pred.matches(testEvent);
        assertTrue(b);

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testSpatial() throws Exception {
        String methodName = "testSpatial";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        MockQuery query = new MockQuery();

        // XMLGregorianCalendar start = df.newXMLGregorianCalendarDate( 2011, 10, 25, 0 );
        // XMLGregorianCalendar end = df.newXMLGregorianCalendarDate( 2011, 10, 27, 0 );
        // query.addTemporalFilter( start, end, Metacard.EFFECTIVE );
        String geometryWkt = "POINT(44.5 34.5)";
        Double inputRadius = 66672.0;
        String linearUnit = Distance.LinearUnit.METER.name();
        String spatialType = "POINT_RADIUS";
        query.addSpatialFilter(geometryWkt, inputRadius, linearUnit, spatialType);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
        LOGGER.debug("resulting predicate: " + pred);

        Filter filter = query.getFilter();
        FilterTransformer transform = new FilterTransformer();
        transform.setIndentation(2);
        String filterXml = transform.transform(filter);
        LOGGER.debug(filterXml);
    }

    @Test
    public void testMultipleCriteriaWithContentTypes() throws Exception {
        String methodName = "testMultipleCriteriaWithContentTypes";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        MockQuery query = new MockQuery();

        DatatypeFactory df = DatatypeFactory.newInstance();
        XMLGregorianCalendar start = df.newXMLGregorianCalendarDate(2011, 10, 25, 0);
        XMLGregorianCalendar end = df.newXMLGregorianCalendarDate(2011, 10, 27, 0);
        query.addTemporalFilter(start, end, Metacard.EFFECTIVE);

        // create content type criteria
        String version1 = "version1";
        String type1 = "type1";

        List<MockTypeVersionsExtension> extensions = new ArrayList<>();
        MockTypeVersionsExtension ext1 = new MockTypeVersionsExtension();
        List<String> ext1Versions = ext1.getVersions();
        ext1Versions.add(version1);
        ext1.setExtensionTypeName(type1);
        extensions.add(ext1);

        query.addTypeFilter(extensions);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
        LOGGER.debug("resulting predicate: " + pred);

        Filter filter = query.getFilter();
        FilterTransformer transform = new FilterTransformer();
        transform.setIndentation(2);
        String filterXml = transform.transform(filter);
        LOGGER.debug(filterXml);

        // input that passes both temporal and content type
        LOGGER.debug("\npass temporal and pass content type.\n");
        MetacardImpl metacard = new MetacardImpl();
        metacard.setCreatedDate(new Date());
        metacard.setExpirationDate(new Date());
        metacard.setModifiedDate(new Date());
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        XMLGregorianCalendar cal = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
        Date effectiveDate = cal.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate);

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + version1);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        Event testEvent = new Event("topic", properties);
        boolean b = pred.matches(testEvent);
        assertTrue(b);

        // input that fails both temporal and content type
        LOGGER.debug("\nfail temporal.  fail content type.\n");
        XMLGregorianCalendar cal1 = df.newXMLGregorianCalendarDate(2012, 10, 30, 0); // time out of
        // range
        Date effectiveDate1 = cal1.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate1);
        LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "invalid_type" + "," + version1);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        // input that passes temporal and fails content type
        LOGGER.debug("\npass temporal.  fail content type\n");
        XMLGregorianCalendar cal2 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
        // range
        Date effectiveDate2 = cal2.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate2);
        LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "invalid_type" + "," + version1);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        // input that fails temporal and passes content type
        LOGGER.debug("\nfail temporal.  pass content type\n");
        XMLGregorianCalendar cal3 = df.newXMLGregorianCalendarDate(2012, 10, 26, 0); // time out of
        // range
        Date effectiveDate3 = cal3.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate3);
        LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + version1);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        // multiple content types
        LOGGER.debug("\nTesting multiple content types.\n");

        String type2 = "type2";
        String version2 = "version2";
        MockTypeVersionsExtension ext2 = new MockTypeVersionsExtension();
        List<String> ext2Versions = ext2.getVersions();
        ext2Versions.add(version2);
        ext2.setExtensionTypeName(type2);
        extensions.add(ext2);

        // No version
        String type3 = "type3";
        MockTypeVersionsExtension ext3 = new MockTypeVersionsExtension();
        ext3.setExtensionTypeName(type3);
        extensions.add(ext3);

        MockQuery query2 = new MockQuery();
        query2.addTemporalFilter(start, end, Metacard.EFFECTIVE);
        query2.addTypeFilter(extensions);
        SubscriptionFilterVisitor visitor1 = new SubscriptionFilterVisitor();
        Predicate pred1 = (Predicate) query2.getFilter().accept(visitor1, null);
        LOGGER.debug("resulting predicate: " + pred1);

        // Create metacard for input
        // time and contentType match
        XMLGregorianCalendar cal4 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
        // range
        Date effectiveDate4 = cal4.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate4);
        LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + version1);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        testEvent = new Event("topic", properties);
        assertTrue(pred1.matches(testEvent));

        // time and contentType match against content type 3 with any version
        XMLGregorianCalendar cal5 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
        // range
        Date effectiveDate5 = cal5.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate5);
        LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type3 + "," + "random_version");
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        testEvent = new Event("topic", properties);
        assertTrue(pred1.matches(testEvent));

        // time matches and contentType matches type2
        XMLGregorianCalendar cal6 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
        // range
        Date effectiveDate6 = cal6.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate6);
        LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type2 + "," + version2);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        testEvent = new Event("topic", properties);
        assertTrue(pred1.matches(testEvent));

        // time matches and content type doesn't match
        XMLGregorianCalendar cal7 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
        // range
        Date effectiveDate7 = cal7.toGregorianCalendar().getTime();
        metacard.setEffectiveDate(effectiveDate7);
        LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

        properties.clear();
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type2 + "," + version1);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        testEvent = new Event("topic", properties);
        assertFalse(pred1.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testMultipleCriteria() throws Exception {
        String methodName = "testMultipleCriteria";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        // test with temporal, spatial, and entry
        MockQuery query = new MockQuery();

        DatatypeFactory df = DatatypeFactory.newInstance();
        XMLGregorianCalendar start = df.newXMLGregorianCalendarDate(2011, 10, 25, 0);
        XMLGregorianCalendar end = df.newXMLGregorianCalendarDate(2011, 10, 27, 0);
        query.addTemporalFilter(start, end, Metacard.MODIFIED);

        String wkt = "POLYGON((0 10, 0 0, 10 0, 10 10, 0 10))";
        query.addSpatialFilter(wkt, 0.0, "Meter", "CONTAINS");

        // create entry criteria
        String catalogId = "ABC123";
        query.addEntryFilter(catalogId);

        MetacardImpl metacard = new MetacardImpl();
        metacard.setLocation("POINT(5 5)");
        metacard.setId(catalogId);
        metacard.setCreatedDate(new Date());
        metacard.setExpirationDate(new Date());
        metacard.setEffectiveDate(new Date());
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        XMLGregorianCalendar cal = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
        Date modifiedDate = cal.toGregorianCalendar().getTime();
        metacard.setModifiedDate(modifiedDate);

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        Event testEvent = new Event("topic", properties);

        // input passes temporal, id, and geo
        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
        LOGGER.debug("resulting predicate: " + pred);

        Filter filter = query.getFilter();
        FilterTransformer transform = new FilterTransformer();
        transform.setIndentation(2);
        String filterXml = transform.transform(filter);
        LOGGER.debug(filterXml);

        assertTrue(pred.matches(testEvent));

        // input passes temporal, id, but fails geo
        metacard.setLocation("POINT(5 50)"); // geo out of range
        properties.clear();
        properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        // Below Pulled from PubSubProviderImpl
        contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        // input passes geo, and id, but fails temporal
        metacard.setLocation("POINT(5 5)");
        XMLGregorianCalendar cal1 = df.newXMLGregorianCalendarDate(2011, 10, 28, 0);
        Date modifiedDate1 = cal1.toGregorianCalendar().getTime();
        metacard.setModifiedDate(modifiedDate1); // date out of range
        properties.clear();
        properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        // Below Pulled from PubSubProviderImpl
        contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        // input passes temporal, geo, but fails id
        XMLGregorianCalendar cal2 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
        Date modifiedDate2 = cal2.toGregorianCalendar().getTime();
        metacard.setModifiedDate(modifiedDate2);
        metacard.setId("invalid_id"); // bad id
        properties.clear();
        properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        // Below Pulled from PubSubProviderImpl
        contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        testEvent = new Event("topic", properties);
        assertFalse(pred.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testContextualQuery() throws Exception {
        String methodName = "testContextualQuery";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        String searchPhrase = "serengeti event";

        MockQuery query = new MockQuery();
        query.addContextualFilter(searchPhrase, null);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate predicate = (Predicate) query.getFilter().accept(visitor, null);

        MetacardImpl metacard = new MetacardImpl();
        metacard.setId("ABC123");
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());
        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        // Above Pulled from PubSubProviderImpl

        Event testEvent = new Event("topic", properties);
        assertTrue(predicate.matches(testEvent));

        contextualMap.clear();
        properties.clear();
        metacard.setMetadata(TestDataLibrary.getDogEntry());
        Directory index1 = ContextualEvaluator.buildIndex(metacard.getMetadata());
        contextualMap.put("DEFAULT_INDEX", index1);
        contextualMap.put("METADATA", metacard.getMetadata());
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
        properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        testEvent = new Event("topic", properties);
        assertFalse(predicate.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testCaseSensitiveContextualQuery() throws Exception {
        String methodName = "testCaseSensitiveContextualQuery";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        String searchPhrase = "laZy BROwn foX";
        Predicate predicate = getPredicate(searchPhrase, true);

        String metadata = String.format(METADATA_FORMAT, "laZy BROwn foX");
        Event testEvent = getEvent(metadata);
        assertTrue(predicate.matches(testEvent));

        metadata = String.format(METADATA_FORMAT, "lazy brown fox");
        testEvent = getEvent(metadata);
        assertFalse(predicate.matches(testEvent));

        metadata = String.format(METADATA_FORMAT, "laZy bROwn foX");
        testEvent = getEvent(metadata);
        assertFalse(predicate.matches(testEvent));

        metadata = String.format(METADATA_FORMAT, "laZyBROwn foX");
        testEvent = getEvent(metadata);
        assertFalse(predicate.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testContextualQuerySpecialMatch() throws IOException {
        for (String term : Arrays.asList(LEADING_TERM, TRAILING_TERM, EMBEDDED_TERM)) {
            for (Character specialChar : ContextualTokenizer.SPECIAL_CHARACTERS_SET) {
                String phrase = String.format(term, specialChar);
                String metadata = String
                        .format(METADATA_FORMAT, StringEscapeUtils.escapeXml(phrase));
                Predicate predicate = getPredicate("\"" + phrase + "\"");
                Event testEvent = getEvent(metadata);
                assertThat(phrase + " not matched", predicate.matches(testEvent),
                        is(equalTo(true)));
            }
        }
    }

    @Test
    public void testContextualQuerySpecialNotMatch() throws IOException {
        for (String term : Arrays.asList(LEADING_TERM, TRAILING_TERM, EMBEDDED_TERM)) {
            for (Character specialChar : ContextualTokenizer.SPECIAL_CHARACTERS_SET) {
                String phrase = String.format(term, specialChar);
                for (Character differentSpecialChar : ContextualTokenizer.SPECIAL_CHARACTERS_SET) {
                    if (specialChar != differentSpecialChar) {
                        String metadata = String.format(METADATA_FORMAT, StringEscapeUtils
                                .escapeXml(String.format(term, differentSpecialChar)));
                        Predicate predicate = getPredicate("\"" + phrase + "\"");
                        Event testEvent = getEvent(metadata);
                        assertThat(phrase + " matched", predicate.matches(testEvent),
                                is(equalTo(false)));
                    }
                }
            }
        }
    }

    @Test
    public void testContextualQuerySurroundedByWildcards() throws Exception {
        Predicate predicate = getPredicate("*test*");
        for (String term : Arrays.asList(LEADING_TERM, TRAILING_TERM, EMBEDDED_TERM)) {
            for (Character specialChar : ContextualTokenizer.SPECIAL_CHARACTERS_SET) {
                String phrase = String.format(term, specialChar);
                String metadata = String
                        .format(METADATA_FORMAT, StringEscapeUtils.escapeXml(phrase));
                Event testEvent = getEvent(metadata);
                assertThat(phrase + " not matched", predicate.matches(testEvent),
                        is(equalTo(true)));
            }
        }
    }

    @Test
    public void testContextualQueryLeadingWildcard() throws Exception {
        Predicate predicate = getPredicate("*test");
        for (String term : Arrays.asList(LEADING_TERM, EMBEDDED_TERM_REVERSED)) {
            for (Character specialChar : ContextualTokenizer.SPECIAL_CHARACTERS_SET) {
                String phrase = String.format(term, specialChar);
                String metadata = String
                        .format(METADATA_FORMAT, StringEscapeUtils.escapeXml(phrase));
                Event testEvent = getEvent(metadata);
                assertThat(phrase + " not matched", predicate.matches(testEvent),
                        is(equalTo(true)));
            }
        }
        for (String term : Arrays.asList(TRAILING_TERM, EMBEDDED_TERM)) {
            for (Character specialChar : ContextualTokenizer.SPECIAL_CHARACTERS_SET) {
                String phrase = String.format(term, specialChar);
                String metadata = String
                        .format(METADATA_FORMAT, StringEscapeUtils.escapeXml(phrase));
                Event testEvent = getEvent(metadata);
                assertThat(phrase + " matched", predicate.matches(testEvent), is(equalTo(false)));
            }
        }
    }

    @Test
    public void testContextualQueryTrailingWildcard() throws Exception {
        Predicate predicate = getPredicate("test*");
        for (String term : Arrays.asList(TRAILING_TERM, EMBEDDED_TERM)) {
            for (Character specialChar : ContextualTokenizer.SPECIAL_CHARACTERS_SET) {
                String phrase = String.format(term, specialChar);
                String metadata = String
                        .format(METADATA_FORMAT, StringEscapeUtils.escapeXml(phrase));
                Event testEvent = getEvent(metadata);
                assertThat(phrase + " not matched", predicate.matches(testEvent),
                        is(equalTo(true)));
            }
        }
        for (String term : Arrays.asList(LEADING_TERM, EMBEDDED_TERM_REVERSED)) {
            for (Character specialChar : ContextualTokenizer.SPECIAL_CHARACTERS_SET) {
                String phrase = String.format(term, specialChar);
                String metadata = String
                        .format(METADATA_FORMAT, StringEscapeUtils.escapeXml(phrase));
                Event testEvent = getEvent(metadata);
                assertThat(phrase + " matched", predicate.matches(testEvent), is(equalTo(false)));
            }
        }
    }

    @Test
    public void testContextualQueryNullMetadata() throws Exception {
        String methodName = "testContextualQueryNullMetadata";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        String searchPhrase = "serengeti event";

        MockQuery query = new MockQuery();
        query.addContextualFilter(searchPhrase, null);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
        Predicate predicate = (Predicate) query.getFilter().accept(visitor, null);

        MetacardImpl metacard = new MetacardImpl();
        metacard.setId("ABC123");
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());
        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        // No contextual map containing indexed metadata added to properties

        Event testEvent = new Event("topic", properties);
        assertFalse(predicate.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testTemporalEvaluator() throws Exception {
        LOGGER.debug(
                "**************************  START: testTemporalEvaluator()  ***********************");

        Calendar calendar = Calendar.getInstance();
        Date start = calendar.getTime();
        Date end = null;
        calendar.setTime(start);
        Date date = calendar.getTime();
        TemporalEvaluationCriteria tec = new TemporalEvaluationCriteriaImpl(end, start, date);
        boolean status = TemporalEvaluator.evaluate(tec);

        assertTrue(status);

        LOGGER.debug(
                "**************************  END: testTemporalEvaluator()  ***********************");
    }

    @Test
    public void testGeospatialEvaluatorOverlaps() throws Exception {
        LOGGER.debug(
                "**************************  START: testGeospatialEvaluator_Overlaps()  ***********************");

        // WKT specifies points in LON LAT order
        String geometryWkt = "POLYGON ((40 34, 40 33, 44.5 33, 44.5 34, 40 34))";
        String operation = "overlaps";
        double distance = 0.0;
        GeospatialPredicate predicate = new GeospatialPredicate(geometryWkt, operation, distance);
        Geometry geoCriteria = predicate.getGeoCriteria();

        String geospatialXml =
                "<gml:Polygon xmlns:gml=\"http://www.opengis.net/gml\" gml:id=\"BGE-1\">\n"
                        + "    <gml:exterior>\n" + "        <gml:LinearRing>\n"
                        + "            <gml:pos>34.0 44.0</gml:pos>\n"
                        + "            <gml:pos>33.0 44.0</gml:pos>\n"
                        + "            <gml:pos>33.0 45.0</gml:pos>\n"
                        + "            <gml:pos>34.0 45.0</gml:pos>\n"
                        + "            <gml:pos>34.0 44.0</gml:pos>\n"
                        + "        </gml:LinearRing>\n" + "    </gml:exterior>\n"
                        + "</gml:Polygon>";

        Geometry input = GeospatialEvaluator.buildGeometry(geospatialXml);
        LOGGER.debug("input.toText() = " + input.toText());
        GeospatialEvaluationCriteria gec = new GeospatialEvaluationCriteriaImpl(geoCriteria,
                operation, input, distance);
        boolean status = GeospatialEvaluator.evaluate(gec);

        assertTrue(status);

        LOGGER.debug(
                "**************************  END: testGeospatialEvaluator_Overlaps()  ***********************");
    }

    @Test
    public void testGeospatialPredicateNullMetadata() throws IOException {
        String methodName = "testGeospatialPredicateNullMetadata()";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        String geometryWkt = "POLYGON ((40 34, 40 33, 44.5 33, 44.5 34, 40 34))";
        String operation = "overlaps";
        double distance = 0.0;
        GeospatialPredicate predicate = new GeospatialPredicate(geometryWkt, operation, distance);

        MetacardImpl metacard = new MetacardImpl();
        metacard.setLocation("POINT (41 34)");

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type1,version1");
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        // No Contextual map added to properties containing indexed metadata

        Event testEvent = new Event("topic", properties);
        assertTrue(predicate.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testGeospatialPredicateNullOperation() throws IOException {
        String methodName = "testGeospatialPredicateNullOperation";
        LOGGER.debug("***************  START: " + methodName + "  *****************");

        String geometryWkt = "POLYGON ((40 34, 40 33, 44.5 33, 44.5 34, 40 34))";
        String operation = "overlaps";
        double distance = 0.0;
        GeospatialPredicate predicate = new GeospatialPredicate(geometryWkt, operation, distance);

        MetacardImpl metacard = new MetacardImpl();
        metacard.setLocation("POINT (41 34)");
        metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "type1,version1");
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, null);
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);

        Event testEvent = new Event("topic", properties);
        assertTrue(predicate.matches(testEvent));

        LOGGER.debug("***************  END: " + methodName + "  *****************");
    }

    @Test
    public void testGeospatialEvaluatorPointRadiusNotContains() throws Exception {
        LOGGER.debug(
                "**************************  START: testGeospatialEvaluator_PointRadius_NotContains()  ***********************");

        // WKT specifies points in LON LAT order
        String geometryWkt = "POINT (44.5 34.5)";
        String operation = "point_radius";
        double distance = 5000.0;
        double radiusInDegrees = (distance * 180.0) / (Math.PI * EQUATORIAL_RADIUS_IN_METERS);
        GeospatialPredicate predicate = new GeospatialPredicate(geometryWkt, operation,
                radiusInDegrees);
        Geometry geoCriteria = predicate.getGeoCriteria();
        LOGGER.debug("geoCriteria.toText() = " + geoCriteria.toText());

        String geospatialXml =
                "<gml:Polygon xmlns:gml=\"http://www.opengis.net/gml\" gml:id=\"BGE-1\">\n"
                        + "    <gml:exterior>\n" + "        <gml:LinearRing>\n"
                        + "            <gml:pos>24.0 22.0</gml:pos>\n"
                        + "            <gml:pos>23.0 22.0</gml:pos>\n"
                        + "            <gml:pos>23.0 24.0</gml:pos>\n"
                        + "            <gml:pos>24.0 24.0</gml:pos>\n"
                        + "            <gml:pos>24.0 22.0</gml:pos>\n"
                        + "        </gml:LinearRing>\n" + "    </gml:exterior>\n"
                        + "</gml:Polygon>";

        Geometry input = GeospatialEvaluator.buildGeometry(geospatialXml);
        LOGGER.debug("input.toText() = " + input.toText());
        GeospatialEvaluationCriteria gec = new GeospatialEvaluationCriteriaImpl(geoCriteria,
                operation, input, radiusInDegrees);
        boolean status = GeospatialEvaluator.evaluate(gec);

        assertFalse(status);

        LOGGER.debug(
                "**************************  END: testGeospatialEvaluator_PointRadius_NotContains()  ***********************");
    }

    @Test
    public void testGeospatialEvaluatorPointRadiusContains() throws Exception {
        LOGGER.debug(
                "**************************  START: testGeospatialEvaluator_PointRadius_Contains()  ***********************");

        // WKT specifies points in LON LAT order
        String geometryWkt = "POINT (44.5 34.5)";
        String operation = "point_radius";
        double distance = 0.6 * NM_PER_DEG_LAT * METERS_PER_NM; // 0.6 degrees
        // latitude in
        // meters
        double radiusInDegrees = (distance * 180.0) / (Math.PI * EQUATORIAL_RADIUS_IN_METERS);
        LOGGER.debug(
                "distance (in meters) = " + distance + ",   radiusInDegrees = " + radiusInDegrees);
        GeospatialPredicate predicate = new GeospatialPredicate(geometryWkt, operation,
                radiusInDegrees);
        Geometry geoCriteria = predicate.getGeoCriteria();
        LOGGER.debug("geoCriteria.toText() = " + geoCriteria.toText());

        String geospatialXml =
                "<gml:Polygon xmlns:gml=\"http://www.opengis.net/gml\" gml:id=\"BGE-1\">\n"
                        + "    <gml:exterior>\n" + "        <gml:LinearRing>\n"
                        + "            <gml:pos>34.0 44.0</gml:pos>\n"
                        + "            <gml:pos>33.0 44.0</gml:pos>\n"
                        + "            <gml:pos>33.0 45.0</gml:pos>\n"
                        + "            <gml:pos>34.0 45.0</gml:pos>\n"
                        + "            <gml:pos>34.0 44.0</gml:pos>\n"
                        + "        </gml:LinearRing>\n" + "    </gml:exterior>\n"
                        + "</gml:Polygon>";

        Geometry input = GeospatialEvaluator.buildGeometry(geospatialXml);
        LOGGER.debug("input.toText() = " + input.toText());
        GeospatialEvaluationCriteria gec = new GeospatialEvaluationCriteriaImpl(geoCriteria,
                operation, input, radiusInDegrees);
        boolean status = GeospatialEvaluator.evaluate(gec);

        assertTrue(status);

        LOGGER.debug(
                "**************************  END: testGeospatialEvaluator_PointRadius_Contains()  ***********************");
    }

    @Test
    public void testSpatialAndTemporalAnd2EntryPredicates() throws Exception {
        // LOGGER.debug("**************************  START: testSpatial_And_Temporal_And_2_EntryPredicates()  ***********************");
        //
        // Calendar calendar = Calendar.getInstance();
        // Date start = calendar.getTime();
        // calendar.add(Calendar.DAY_OF_YEAR, 1); // add one day to the date/calendar
        // Date end = calendar.getTime();
        //
        // TemporalCriteria temporalCriteria = new TemporalCriteria(start, end, TimeType.EFFECTIVE);
        //
        // String geometryWKT = "POLYGON ((0 10, 0 30, 20 30, 20 10, 0 10))";
        // int maxNeighborResults = 0;
        // SpatialCriteria spatialCriteria = new SpatialCriteria(geometryWKT, new
        // Integer(maxNeighborResults), null, SpatialType.CONTAINS);
        //
        // EntryCriteria entryCriteria1 = new EntryCriteria("a47238c1db7e44ba7f00000100a8654b");
        //
        // EntryCriteria entryCriteria2 = new EntryCriteria("a47238c1db7e44ba7f00000100a8ffff");
        //
        // FilterNode entries = new BinaryOperationImpl(entryCriteria1, entryCriteria2,
        // LogicalOperator.OR, true);
        // FilterNode temporal = new BinaryOperationImpl(temporalCriteria, entries,
        // LogicalOperator.AND, true);
        // FilterNode root = new BinaryOperationImpl(spatialCriteria, temporal, LogicalOperator.AND,
        // true);
        //
        // MockSubscription subscription = new MockSubscription(null, root, new
        // MockDeliveryMethod());
        //
        // PubSubProviderImpl pubSub = new PubSubProviderImpl(new MockBundle().getBundleContext(),
        // new MockEventAdmin());
        // Predicate finalPredicate = pubSub.createFinalPredicate(subscription);
        // LOGGER.debug("finalPredicate:\n" + finalPredicate.toString());
        //
        // LOGGER.debug("**************************  END: testSpatial_And_Temporal_And_2_EntryPredicates()  ***********************");
    }

    @Test
    public void testSpatialOrTemporalAnd2EntryPredicates() throws Exception {
        // LOGGER.debug("**************************  START: testSpatial_Or_Temporal_And_2_EntryPredicates()  ***********************");
        //
        // Calendar calendar = Calendar.getInstance();
        // Date start = calendar.getTime();
        // calendar.add(Calendar.DAY_OF_YEAR, 1); // add one day to the date/calendar
        // Date end = calendar.getTime();
        //
        // TemporalCriteria temporalCriteria = new TemporalCriteria(start, end, TimeType.EFFECTIVE);
        //
        // String geometryWKT = "POLYGON ((0 10, 0 30, 20 30, 20 10, 0 10))";
        // int maxNeighborResults = 0;
        // SpatialCriteria spatialCriteria = new SpatialCriteria(geometryWKT, new
        // Integer(maxNeighborResults), null, SpatialType.CONTAINS);
        //
        // EntryCriteria entryCriteria1 = new EntryCriteria("a47238c1db7e44ba7f00000100a8654b");
        //
        // EntryCriteria entryCriteria2 = new EntryCriteria("a47238c1db7e44ba7f00000100a8ffff");
        //
        // FilterNode entries = new BinaryOperationImpl(entryCriteria1, entryCriteria2,
        // LogicalOperator.OR, true);
        // FilterNode temporal = new BinaryOperationImpl(temporalCriteria, entries,
        // LogicalOperator.AND, true);
        // FilterNode root = new BinaryOperationImpl(spatialCriteria, temporal, LogicalOperator.OR,
        // true);
        //
        // MockSubscription subscription = new MockSubscription(null, root, new
        // MockDeliveryMethod());
        //
        // PubSubProviderImpl pubSub = new PubSubProviderImpl(new MockBundle().getBundleContext(),
        // new MockEventAdmin());
        // Predicate finalPredicate = pubSub.createFinalPredicate(subscription);
        // LOGGER.debug("finalPredicate:\n" + finalPredicate.toString());
        //
        // LOGGER.debug("**************************  END: testSpatial_Or_Temporal_And_2_EntryPredicates()  ***********************");
    }

    @Test
    public void testContentTypeEvaluatorOnlyTypeMatch() throws Exception {
        LOGGER.debug(
                "**************************  START: testContentTypeEvaluator_OnlyType_Match()  ***********************");

        // Match on "nitf", all versions
        ContentTypePredicate predicate = new ContentTypePredicate("nitf", null);

        String inputContentType = "nitf,v20";

        ContentTypeEvaluationCriteriaImpl ctec = new ContentTypeEvaluationCriteriaImpl(predicate,
                inputContentType);

        boolean status = ContentTypeEvaluator.evaluate(ctec);
        assertTrue(status);

        LOGGER.debug(
                "**************************  END: testContentTypeEvaluator_OnlyType_Match()  ***********************");
    }

    @Test
    public void testContentTypeEvaluatorOnlyTypeNoMatch() throws Exception {
        LOGGER.debug(
                "**************************  START: testContentTypeEvaluator_OnlyType_NoMatch()  ***********************");

        // Match on "nitf", all versions
        ContentTypePredicate predicate = new ContentTypePredicate("nitf", null);

        String inputContentType = "video,v20";

        ContentTypeEvaluationCriteriaImpl ctec = new ContentTypeEvaluationCriteriaImpl(predicate,
                inputContentType);

        boolean status = ContentTypeEvaluator.evaluate(ctec);
        assertFalse(status);

        LOGGER.debug(
                "**************************  END: testContentTypeEvaluator_OnlyType_NoMatch()  ***********************");
    }

    @Test
    public void testContentTypeEvaluatorTypeAndVersionMatch() throws Exception {
        LOGGER.debug(
                "**************************  START: testContentTypeEvaluator_TypeAndVersion_Match()  ***********************");

        // Match on "nitf, v20"
        ContentTypePredicate predicate = new ContentTypePredicate("nitf", "v20");

        String inputContentType = "nitf,v20";

        ContentTypeEvaluationCriteriaImpl ctec = new ContentTypeEvaluationCriteriaImpl(predicate,
                inputContentType);

        boolean status = ContentTypeEvaluator.evaluate(ctec);
        assertTrue(status);

        LOGGER.debug(
                "**************************  END: testContentTypeEvaluator_TypeAndVersion_Match()  ***********************");
    }

    @Test
    public void testContentTypeEvaluatorTypeAndVersionTypeMismatch() throws Exception {
        LOGGER.debug(
                "**************************  START: testContentTypeEvaluator_TypeAndVersion_TypeMismatch()  ***********************");

        // Match on "nitf, v20"
        ContentTypePredicate predicate = new ContentTypePredicate("nitf", "v20");

        String inputContentType = "video,v20";

        ContentTypeEvaluationCriteriaImpl ctec = new ContentTypeEvaluationCriteriaImpl(predicate,
                inputContentType);

        boolean status = ContentTypeEvaluator.evaluate(ctec);
        assertFalse(status);

        LOGGER.debug(
                "**************************  END: testContentTypeEvaluator_TypeAndVersion_TypeMismatch()  ***********************");
    }

    @Test
    public void testContentTypeEvaluatorTypeAndVersionVersionMismatch() throws Exception {
        LOGGER.debug(
                "**************************  START: testContentTypeEvaluator_TypeAndVersion_VersionMismatch()  ***********************");

        // Match on "nitf, v20"
        ContentTypePredicate predicate = new ContentTypePredicate("nitf", "v20");

        String inputContentType = "nitf,v20_Army";

        ContentTypeEvaluationCriteriaImpl ctec = new ContentTypeEvaluationCriteriaImpl(predicate,
                inputContentType);

        boolean status = ContentTypeEvaluator.evaluate(ctec);
        assertFalse(status);

        LOGGER.debug(
                "**************************  END: testContentTypeEvaluator_TypeAndVersion_VersionMismatch()  ***********************");
    }

    /*
     * DEBUG - for testing CaseSensitiveStandardAnalyzer
     *
     * @Test public void testAnalyzers() throws Exception { String[] strings = {
     * "The QUICK brown Fox jumped over the laZy dogs" };
     *
     * for (int i = 0; i < strings.length; i++) { analyze( "contents", strings[i] ); } } END DEBUG
     */

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * @param typesVersions List of types and versions where each type/version pairs are pipe delimited and
     *                      each type/version is comma-delimited
     */
    private List<MockTypeVersionsExtension> createContentTypeVersionList(String typesVersions) {
        List<MockTypeVersionsExtension> extensions = new ArrayList<>();

        LOGGER.debug("typesVersions = " + typesVersions);
        String[] typeVersionPairs = typesVersions.split("\\|");
        for (String typeVersionPair : typeVersionPairs) {
            LOGGER.debug("typeVersionPair = " + typeVersionPair);
            MockTypeVersionsExtension ext = null;
            String[] pair = typeVersionPair.split(",");
            LOGGER.debug("pair.length = " + pair.length);
            String type = pair[0];
            String version = null;
            if (pair.length == 2) {
                version = pair[1];
            }

            if (type != null && !type.isEmpty()) {
                ext = new MockTypeVersionsExtension();
                ext.setExtensionTypeName(type);
            }

            if (version != null && !version.isEmpty()) {
                if (ext == null) {
                    ext = new MockTypeVersionsExtension();
                }
                List<String> extVersions = ext.getVersions();
                extVersions.add(version);
            }

            if (ext != null) {
                extensions.add(ext);
            }
        }

        return extensions;
    }

    private Predicate getPredicate(String searchPhrase) {
        return getPredicate(searchPhrase, null, false);
    }

    private Predicate getPredicate(String searchPhrase, boolean caseSensitive) {
        return getPredicate(searchPhrase, null, caseSensitive);
    }

    private Predicate getPredicate(String searchPhrase, String textPathSections,
            boolean caseSensitive) {
        MockQuery query = new MockQuery();
        query.addContextualFilter(searchPhrase, textPathSections, caseSensitive);

        SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();

        return (Predicate) query.getFilter().accept(visitor, null);
    }

    private Event getEvent(String metadata) throws IOException {
        MetacardImpl metacard = new MetacardImpl();
        metacard.setId("ABC123");
        metacard.setMetadata(metadata);
        HashMap<String, Object> properties = new HashMap<>();
        properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
        properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
        properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

        Map<String, Object> contextualMap = constructContextualMap(metacard);
        properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);

        return new Event("topic", properties);
    }

    // private static void analyze( String fieldName, String text ) throws IOException
    // {
    // System.out.println("Analzying \"" + text + "\"");
    // for (int i = 0; i < analyzers.length; i++)
    // {
    // Analyzer analyzer = analyzers[i];
    // System.out.println("\t" + analyzer.getClass().getName() + ":");
    // System.out.print("\t\t");
    //
    // String term = "";
    // TokenStream ts = analyzer.tokenStream( fieldName, new StringReader( text ) );
    // TermAttribute termAttribute = (TermAttribute) ts.getAttribute(TermAttribute.class);
    // termAttribute = (TermAttribute) ts.getAttribute(TermAttribute.class);
    // while (ts.incrementToken())
    // {
    // term = termAttribute.term();
    // //System.out.println("token: " + term);
    // System.out.print("[" + term + "] ");
    // }
    // System.out.println("\n");
    // }
    // }

}