/**
 * Return <code>true</code> if the context-relative request path
 * matches the requirements of the specified filter mapping;
 * otherwise, return <code>false</code>.
 *
 * @param filterMap Filter mapping being checked
 * @param requestPath Context-relative request path of this request
 */
private static boolean matchFiltersURL(FilterMap filterMap, String requestPath) {

    // Check the specific "*" special URL pattern, which also matches
    // named dispatches
    if (filterMap.getMatchAllUrlPatterns())
        return true;

    if (requestPath == null)
        return false;

    // Match on context relative request path
    String[] testPaths = filterMap.getURLPatterns();

    for (int i = 0; i < testPaths.length; i++) {
        if (matchFiltersURL(testPaths[i], requestPath)) {
            return true;
        }
    }

    // No match
    return false;

}
 

/**
 * Return <code>true</code> if the specified servlet name matches
 * the requirements of the specified filter mapping; otherwise
 * return <code>false</code>.
 *
 * @param filterMap Filter mapping being checked
 * @param servletName Servlet name being checked
 */
private static boolean matchFiltersServlet(FilterMap filterMap,
                                    String servletName) {

    if (servletName == null) {
        return false;
    }
    // Check the specific "*" special servlet name
    else if (filterMap.getMatchAllServletNames()) {
        return true;
    } else {
        String[] servletNames = filterMap.getServletNames();
        for (int i = 0; i < servletNames.length; i++) {
            if (servletName.equals(servletNames[i])) {
                return true;
            }
        }
        return false;
    }

}
 

private synchronized void init() throws Exception {
    if (init) return;

    Tomcat tomcat = getTomcatInstance();
    Context root = tomcat.addContext("", TEMP_DIR);
    Tomcat.addServlet(root, "Bug37794", new Bug37794Servlet());
    root.addServletMappingDecoded("/test", "Bug37794");

    if (createFilter) {
        FilterDef failedRequestFilter = new FilterDef();
        failedRequestFilter.setFilterName("failedRequestFilter");
        failedRequestFilter.setFilterClass(
                FailedRequestFilter.class.getName());
        FilterMap failedRequestFilterMap = new FilterMap();
        failedRequestFilterMap.setFilterName("failedRequestFilter");
        failedRequestFilterMap.addURLPatternDecoded("/*");
        root.addFilterDef(failedRequestFilter);
        root.addFilterMap(failedRequestFilterMap);
    }

    tomcat.start();

    setPort(tomcat.getConnector().getLocalPort());

    init = true;
}
 

private MockFilterChain testRemoteIpFilter(FilterDef filterDef, Request request)
        throws LifecycleException, IOException, ServletException {
    Tomcat tomcat = getTomcatInstance();
    Context root = tomcat.addContext("", TEMP_DIR);

    RemoteIpFilter remoteIpFilter = new RemoteIpFilter();
    filterDef.setFilterClass(RemoteIpFilter.class.getName());
    filterDef.setFilter(remoteIpFilter);
    filterDef.setFilterName(RemoteIpFilter.class.getName());
    root.addFilterDef(filterDef);

    FilterMap filterMap = new FilterMap();
    filterMap.setFilterName(RemoteIpFilter.class.getName());
    filterMap.addURLPatternDecoded("*");
    root.addFilterMap(filterMap);

    getTomcatInstance().start();

    MockFilterChain filterChain = new MockFilterChain();

    // TEST
    TesterResponse response = new TesterResponse();
    response.setRequest(request);
    remoteIpFilter.doFilter(request, response, filterChain);
    return filterChain;
}
 

private static void configureTest46243Context(Context context, boolean fail) {
    // Add a test filter that fails
    FilterDef filterDef = new FilterDef();
    filterDef.setFilterClass(Bug46243Filter.class.getName());
    filterDef.setFilterName("Bug46243");
    filterDef.addInitParameter("fail", Boolean.toString(fail));
    context.addFilterDef(filterDef);
    FilterMap filterMap = new FilterMap();
    filterMap.setFilterName("Bug46243");
    filterMap.addURLPatternDecoded("*");
    context.addFilterMap(filterMap);

    // Add a test servlet so there is something to generate a response if
    // it works (although it shouldn't)
    Tomcat.addServlet(context, "Bug46243", new HelloWorldServlet());
    context.addServletMappingDecoded("/", "Bug46243");
}
 

@Override
public void deployConfig(WebApplicationContext wac, Filter... filters) {
	Assert.state(this.port != -1, "setup() was never called.");
	this.context = this.tomcatServer.addContext("", System.getProperty("java.io.tmpdir"));
	this.context.addApplicationListener(WsContextListener.class.getName());
	Tomcat.addServlet(this.context, "dispatcherServlet", new DispatcherServlet(wac)).setAsyncSupported(true);
	this.context.addServletMappingDecoded("/", "dispatcherServlet");
	for (Filter filter : filters) {
		FilterDef filterDef = new FilterDef();
		filterDef.setFilterName(filter.getClass().getName());
		filterDef.setFilter(filter);
		filterDef.setAsyncSupported("true");
		this.context.addFilterDef(filterDef);
		FilterMap filterMap = new FilterMap();
		filterMap.setFilterName(filter.getClass().getName());
		filterMap.addURLPattern("/*");
		filterMap.setDispatcher("REQUEST,FORWARD,INCLUDE,ASYNC");
		this.context.addFilterMap(filterMap);
	}
}
 

@Override
public void deployConfig(WebApplicationContext wac, Filter... filters) {
	Assert.state(this.port != -1, "setup() was never called.");
	this.context = this.tomcatServer.addContext("", System.getProperty("java.io.tmpdir"));
	this.context.addApplicationListener(WsContextListener.class.getName());
	Tomcat.addServlet(this.context, "dispatcherServlet", new DispatcherServlet(wac)).setAsyncSupported(true);
	this.context.addServletMappingDecoded("/", "dispatcherServlet");
	for (Filter filter : filters) {
		FilterDef filterDef = new FilterDef();
		filterDef.setFilterName(filter.getClass().getName());
		filterDef.setFilter(filter);
		filterDef.setAsyncSupported("true");
		this.context.addFilterDef(filterDef);
		FilterMap filterMap = new FilterMap();
		filterMap.setFilterName(filter.getClass().getName());
		filterMap.addURLPattern("/*");
		filterMap.setDispatcher("REQUEST,FORWARD,INCLUDE,ASYNC");
		this.context.addFilterMap(filterMap);
	}
}
 

@Override
public void deployConfig(WebApplicationContext wac, Filter... filters) {
	Assert.state(this.port != -1, "setup() was never called.");
	this.context = this.tomcatServer.addContext("", System.getProperty("java.io.tmpdir"));
       this.context.addApplicationListener(WsContextListener.class.getName());
	Tomcat.addServlet(this.context, "dispatcherServlet", new DispatcherServlet(wac)).setAsyncSupported(true);
	this.context.addServletMapping("/", "dispatcherServlet");
	for (Filter filter : filters) {
		FilterDef filterDef = new FilterDef();
		filterDef.setFilterName(filter.getClass().getName());
		filterDef.setFilter(filter);
		filterDef.setAsyncSupported("true");
		this.context.addFilterDef(filterDef);
		FilterMap filterMap = new FilterMap();
		filterMap.setFilterName(filter.getClass().getName());
		filterMap.addURLPattern("/*");
		filterMap.setDispatcher("REQUEST,FORWARD,INCLUDE,ASYNC");
		this.context.addFilterMap(filterMap);
	}
}
 

/**
 * Return the set of filter mappings for this Context.
 * @return a string array with a representation of all the filter mappings
 * @throws MBeanException propagated from the managed resource access
 */
public String[] findFilterMaps() throws MBeanException {

    Context context = doGetManagedResource();

    FilterMap[] maps = context.findFilterMaps();
    String[] stringMaps = new String[maps.length];
    for (int counter = 0; counter < maps.length; counter++) {
        stringMaps[counter] = maps[counter].toString();
    }

    return stringMaps;
}
 

/**
 * Convenience method which returns true if  the dispatcher type
 * matches the dispatcher types specified in the FilterMap
 */
private static boolean matchDispatcher(FilterMap filterMap, DispatcherType type) {
    switch (type) {
        case FORWARD :
            if ((filterMap.getDispatcherMapping() & FilterMap.FORWARD) != 0) {
                return true;
            }
            break;
        case INCLUDE :
            if ((filterMap.getDispatcherMapping() & FilterMap.INCLUDE) != 0) {
                return true;
            }
            break;
        case REQUEST :
            if ((filterMap.getDispatcherMapping() & FilterMap.REQUEST) != 0) {
                return true;
            }
            break;
        case ERROR :
            if ((filterMap.getDispatcherMapping() & FilterMap.ERROR) != 0) {
                return true;
            }
            break;
        case ASYNC :
            if ((filterMap.getDispatcherMapping() & FilterMap.ASYNC) != 0) {
                return true;
            }
            break;
    }
    return false;
}
 

@Override
public void addMappingForServletNames(
        EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter,
        String... servletNames) {

    FilterMap filterMap = new FilterMap();

    filterMap.setFilterName(filterDef.getFilterName());

    if (dispatcherTypes != null) {
        for (DispatcherType dispatcherType : dispatcherTypes) {
            filterMap.setDispatcher(dispatcherType.name());
        }
    }

    if (servletNames != null) {
        for (String servletName : servletNames) {
            filterMap.addServletName(servletName);
        }

        if (isMatchAfter) {
            context.addFilterMap(filterMap);
        } else {
            context.addFilterMapBefore(filterMap);
        }
    }
    // else error?
}
 

@Override
public void addMappingForUrlPatterns(
        EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter,
        String... urlPatterns) {

    FilterMap filterMap = new FilterMap();

    filterMap.setFilterName(filterDef.getFilterName());

    if (dispatcherTypes != null) {
        for (DispatcherType dispatcherType : dispatcherTypes) {
            filterMap.setDispatcher(dispatcherType.name());
        }
    }

    if (urlPatterns != null) {
        // % decoded (if necessary) using UTF-8
        for (String urlPattern : urlPatterns) {
            filterMap.addURLPattern(urlPattern);
        }

        if (isMatchAfter) {
            context.addFilterMap(filterMap);
        } else {
            context.addFilterMapBefore(filterMap);
        }
    }
    // else error?

}
 

@Override
public Collection<String> getServletNameMappings() {
    Collection<String> result = new HashSet<>();

    FilterMap[] filterMaps = context.findFilterMaps();

    for (FilterMap filterMap : filterMaps) {
        if (filterMap.getFilterName().equals(filterDef.getFilterName())) {
            for (String servletName : filterMap.getServletNames()) {
                result.add(servletName);
            }
        }
    }
    return result;
}
 

@Override
public Collection<String> getUrlPatternMappings() {
    Collection<String> result = new HashSet<>();

    FilterMap[] filterMaps = context.findFilterMaps();

    for (FilterMap filterMap : filterMaps) {
        if (filterMap.getFilterName().equals(filterDef.getFilterName())) {
            for (String urlPattern : filterMap.getURLPatterns()) {
                result.add(urlPattern);
            }
        }
    }
    return result;
}
 

private void setUpApplication() throws Exception {
    context = tomcat.addContext(CONTEXT_PATH_LOGIN, System.getProperty("java.io.tmpdir"));
    context.setSessionTimeout(SHORT_SESSION_TIMEOUT_MINS);

    Tomcat.addServlet(context, SERVLET_NAME, new TesterServlet());
    context.addServletMappingDecoded(URI_PROTECTED, SERVLET_NAME);

    FilterDef filterDef = new FilterDef();
    filterDef.setFilterName(FILTER_NAME);
    filterDef.setFilterClass(RestCsrfPreventionFilter.class.getCanonicalName());
    filterDef.addInitParameter(FILTER_INIT_PARAM, REMOVE_CUSTOMER + "," + ADD_CUSTOMER);
    context.addFilterDef(filterDef);

    FilterMap filterMap = new FilterMap();
    filterMap.setFilterName(FILTER_NAME);
    filterMap.addURLPatternDecoded(URI_CSRF_PROTECTED);
    context.addFilterMap(filterMap);

    SecurityCollection collection = new SecurityCollection();
    collection.addPatternDecoded(URI_PROTECTED);

    SecurityConstraint sc = new SecurityConstraint();
    sc.addAuthRole(ROLE);
    sc.addCollection(collection);
    context.addConstraint(sc);

    LoginConfig lc = new LoginConfig();
    lc.setAuthMethod(METHOD);
    context.setLoginConfig(lc);

    AuthenticatorBase basicAuthenticator = new BasicAuthenticator();
    context.getPipeline().addValve(basicAuthenticator);
}
 

private void doTest(String encoding, String expected, int mode, boolean useSetContentType)
        throws Exception {
    // Setup Tomcat instance
    Tomcat tomcat = getTomcatInstance();

    // No file system docBase required
    Context ctx = tomcat.addContext("", null);

    // Add the Servlet
    CharsetServlet servlet = new CharsetServlet(mode, useSetContentType);
    Tomcat.addServlet(ctx, "servlet", servlet);
    ctx.addServletMappingDecoded("/", "servlet");

    // Add the Filter
    FilterDef filterDef = new FilterDef();
    filterDef.setFilterClass(AddDefaultCharsetFilter.class.getName());
    filterDef.setFilterName("filter");
    if (encoding != null) {
        filterDef.addInitParameter("encoding", encoding);
    }
    ctx.addFilterDef(filterDef);
    FilterMap filterMap = new FilterMap();
    filterMap.setFilterName("filter");
    filterMap.addServletName("servlet");
    ctx.addFilterMap(filterMap);

    tomcat.start();

    Map<String, List<String>> headers = new HashMap<>();
    getUrl("http://localhost:" + getPort() + "/", new ByteChunk(), headers);

    String ct = getSingleHeader("Content-Type", headers).toLowerCase(Locale.ENGLISH);
    Assert.assertEquals("text/plain;charset=" + expected.toLowerCase(Locale.ENGLISH), ct);
}
 

/**
 * 动态删除过滤器
 * @param name              过滤器名
 * @param servletContext    ServletContext
 * @return  删除是否成功
 */
public static boolean removeDynamicFilter(String name, ServletContext servletContext) {
    Context standContext = ReflectUtil.invokeFieldPath(servletContext, "context.context");
    if (standContext == null) {
        log.warn("Hydrogen filter find path '((ApplicationContextFacade) servletContext).context.context' fail.");
        return false;
    }

    // ((ApplicationContextFacade) servletContext).context.context.filterMaps（在filterChain里根据映射的filterMaps转filterConfigs）
    FilterMap[] filterMaps = ReflectUtil.invokeMethod(standContext, "findFilterMaps", null);
    if (filterMaps == null) {
        log.warn("Hydrogen filter find path '((ApplicationContextFacade) servletContext).context.context.findFilterMaps()' fail.");
        return false;
    }
    for (FilterMap filterMap : filterMaps) {
        if (filterMap.getFilterName().equals(name)) {
            ReflectUtil.invokeMethod(standContext, "removeFilterMap", new Class[]{FilterMap.class}, filterMap);
            break;
        }
    }

    // ((ApplicationContextFacade) servletContext).context.context.filterDefs（filterMaps和filterConfigs的数据源，并提供给外部接口访问）
    FilterDef filterDef = ReflectUtil.invokeMethod(standContext, "findFilterDef", new Class[]{String.class}, name);
    if (filterDef != null) {
        ReflectUtil.invokeMethod(standContext, "removeFilterDef", new Class[]{FilterDef.class}, filterDef);
    }

    // ((ApplicationContextFacade) servletContext).context.context.filterConfigs (FilterChain具体会读这个属性里的过滤器）
    Map<String, ApplicationFilterConfig> filterConfigs = ReflectUtil.invokeFieldPath(standContext, "filterConfigs");
    if (filterConfigs == null) {
        log.warn("Hydrogen filter find path '((ApplicationContextFacade) servletContext).context.context.filterConfigs' fail.");
        return false;
    }
    filterConfigs.remove(name);

    // boolean ((ApplicationContextFacade) servletContext).context.context.filterStart() (把filterDefs加载到filterConfigs)
    return (boolean) ReflectUtil.invokeMethod(standContext, "filterStart", null);
}
 

public static void setUpTomcat(String dataSourceFactory) throws LifecycleException, ServletException {
    // create a tomcat instance
    tomcat = new Tomcat();
    tomcat.setBaseDir(".");
    tomcat.setPort(0);
    tomcat.enableNaming();

    // create a context with our test servlet
    Context ctx = tomcat.addContext(CONTEXT_PATH, new File(".").getAbsolutePath());
    Tomcat.addServlet(ctx, SERVLET_NAME, new TestServlet());
    ctx.addServletMappingDecoded("/*", SERVLET_NAME);

    // add our metrics filter
    FilterDef def = new FilterDef();
    def.setFilterClass(TomcatServletMetricsFilter.class.getName());
    def.setFilterName("metricsFilter");
    def.addInitParameter("buckets",".01, .05, .1, .25, .5, 1, 2.5, 5, 10, 30");
    ctx.addFilterDef(def);
    FilterMap map = new FilterMap();
    map.setFilterName("metricsFilter");
    map.addURLPattern("/*");
    ctx.addFilterMap(map);

    // create a datasource
    ContextResource resource = new ContextResource();
    resource.setName("jdbc/db");
    resource.setAuth("Container");
    resource.setType("javax.sql.DataSource");
    resource.setScope("Sharable");
    resource.setProperty("name", "foo");
    resource.setProperty("factory", dataSourceFactory);
    resource.setProperty("driverClassName", "org.h2.Driver");
    resource.setProperty("url", "jdbc:h2:mem:dummy");
    resource.setProperty("jdbcInterceptors", "nl.nlighten.prometheus.tomcat.TomcatJdbcInterceptor(logFailed=true,logSlow=true,threshold=0,buckets=.01|.05|.1|1|10,slowQueryBuckets=1|10|30)");
    ctx.getNamingResources().addResource(resource);

    // start instance
    tomcat.init();
    tomcat.start();
}
 

@Override
public void customize(Context context) {
    context.addApplicationListener("org.apache.tomcat.websocket.server.WsContextListener");
    context.addErrorPage(new ErrorPage() {
        @Override
        public int getErrorCode() {
            return 404;
        }

        @Override
        public String getLocation() {
            return "/404";
        }
    });
    context.addErrorPage(new ErrorPage() {
        @Override
        public int getErrorCode() {
            return 500;
        }

        @Override
        public String getLocation() {
            return "/error";
        }
    });

    // CORS access is wide open
    FilterDef corsFilter = new FilterDef();
    corsFilter.setFilterName("CorsFilter");
    corsFilter.setFilterClass("org.apache.catalina.filters.CorsFilter");
    corsFilter.addInitParameter("cors.allowed.methods", "GET,POST,PUT,DELETE,HEAD,OPTIONS");
    corsFilter.addInitParameter("cors.allowed.headers", "Authorization,Content-Type,X-Requested-With,Accept,Origin,Access-Control-Request-Method,Access-Control-Request-Headers,Accept-Encoding,Accept-Language,Cache-Control,Connection,Host,Pragma,Referer,User-Agent");
    corsFilter.addInitParameter("cors.allowed.origins", "*");
    context.addFilterDef(corsFilter);
    FilterMap filterMap = new FilterMap();
    filterMap.setFilterName(corsFilter.getFilterName());
    filterMap.addURLPattern("/api/*");
    filterMap.addURLPattern("/services/AppSummary");
    context.addFilterMap(filterMap);
}
 

@Override
public void addFilterMapping(final FilterMap filterMap) {
    // we need to add this one before the mapping cause of tomcat validation (ie dont make deployment fail)
    if ("CDI Conversation Filter".equals(filterMap.getFilterName()) && !cdiConversation) {
        final FilterDef conversationFilter = new FilterDef();
        conversationFilter.setAsyncSupported("true");
        conversationFilter.setDescription("CDI Conversation Filter");
        conversationFilter.setDisplayName("CDI Conversation Filter");
        conversationFilter.setFilterName("CDI Conversation Filter");
        conversationFilter.setFilterClass(WebConversationFilter.class.getName());
        addFilter(conversationFilter);
        cdiConversation = true;
    }
    super.addFilterMapping(filterMap);
}
 

public void startTomcat() throws LifecycleException {
    tomcat = new Tomcat();
    tomcat.setPort(randomPort);
    tomcat.setHostname("localhost");
    String appBase = ".";
    tomcat.getHost().setAppBase(appBase);

    File docBase = new File(System.getProperty("java.io.tmpdir"));
    Context context = tomcat.addContext("", docBase.getAbsolutePath());

    // add a servlet
    Class servletClass = MyServlet.class;
    Tomcat.addServlet(context, servletClass.getSimpleName(), servletClass.getName());
    context.addServletMappingDecoded("/my-servlet/*", servletClass.getSimpleName());

    // add a filter and filterMapping
    Class filterClass = MyFilter.class;
    FilterDef myFilterDef = new FilterDef();
    myFilterDef.setFilterClass(filterClass.getName());
    myFilterDef.setFilterName(filterClass.getSimpleName());
    context.addFilterDef(myFilterDef);

    FilterMap myFilterMap = new FilterMap();
    myFilterMap.setFilterName(filterClass.getSimpleName());
    myFilterMap.addURLPattern("/my-servlet/*");
    context.addFilterMap(myFilterMap);

    tomcat.start();
    // uncomment for live test
    // tomcat
    // .getServer()
    // .await();
}
 

@Override
public void addFilterMap(FilterMap filterMap) { /* NO-OP */ }
 

@Override
public void addFilterMapBefore(FilterMap filterMap) { /* NO-OP */ }
 

@Override
public FilterMap[] findFilterMaps() { return null; }
 

@Override
public void removeFilterMap(FilterMap filterMap) { /* NO-OP */ }
 

@Test
public void testOverwriteFilterMapping() throws Exception {
    WebXml webxml = new WebXml();
    Map<String,JavaClassCacheEntry> javaClassCache = new HashMap<>();
    FilterDef filterDef = new FilterDef();
    filterDef.setFilterName("paramFilter");
    filterDef.setFilterClass("org.apache.catalina.startup.ParamFilter");
    filterDef.addInitParameter("message", "tomcat");
    filterDef.setDescription("Description");
    filterDef.setDisplayName("DisplayName");
    filterDef.setLargeIcon("LargeIcon");
    filterDef.setSmallIcon("SmallIcon");
    filterDef.setAsyncSupported("true");


    webxml.addFilter(filterDef);
    FilterMap filterMap = new FilterMap();
    filterMap.addURLPatternDecoded("/param1");
    filterMap.setFilterName("paramFilter");
    webxml.addFilterMapping(filterMap);

    ContextConfig config = new ContextConfig();
    File sFile = paramClassResource(
            "org/apache/catalina/startup/ParamServlet");
    config.processAnnotationsFile(sFile, webxml, false, javaClassCache);
    File fFile = paramClassResource(
            "org/apache/catalina/startup/ParamFilter");
    config.processAnnotationsFile(fFile, webxml, false, javaClassCache);
    FilterDef fdef = webxml.getFilters().get("paramFilter");
    Assert.assertNotNull(fdef);
    Assert.assertEquals(filterDef,fdef);
    Assert.assertEquals("tomcat",fdef.getParameterMap().get("message"));
    Set<FilterMap> filterMappings = webxml.getFilterMappings();
    Assert.assertTrue(filterMappings.contains(filterMap));
    // annotation mapping not added s. Servlet Spec 3.0 (Nov 2009)
    // 8.2.3.3.vi page 81
    String[] urlPatterns = filterMap.getURLPatterns();
    Assert.assertNotNull(urlPatterns);
    Assert.assertEquals(1,urlPatterns.length);
    Assert.assertEquals("/param1",urlPatterns[0]);

    // check simple Parameter
    Assert.assertEquals("Description", fdef.getDescription());
    Assert.assertEquals("DisplayName", fdef.getDisplayName());
    Assert.assertEquals("LargeIcon", fdef.getLargeIcon());
    Assert.assertEquals("SmallIcon", fdef.getSmallIcon());
    // FIXME: Strange why servletDef is Boolean and FilterDef is String?
    Assert.assertEquals("true", fdef.getAsyncSupported());

    String[] dis = filterMap.getDispatcherNames();
    Assert.assertEquals(2, dis.length);
    Assert.assertEquals(DispatcherType.ERROR.toString(),dis[0]);
    Assert.assertEquals(DispatcherType.ASYNC.toString(),dis[1]);

}
 

@Test
public void testWithTomcatServer() throws Exception {

    // mostly default configuration : enable "x-forwarded-proto"
    Map<String, String> remoteIpFilterParameter = new HashMap<>();
    remoteIpFilterParameter.put("protocolHeader", "x-forwarded-proto");

    // SETUP
    Tomcat tomcat = getTomcatInstance();
    Context root = tomcat.addContext("", TEMP_DIR);

    FilterDef filterDef = new FilterDef();
    filterDef.getParameterMap().putAll(remoteIpFilterParameter);
    filterDef.setFilterClass(RemoteIpFilter.class.getName());
    filterDef.setFilterName(RemoteIpFilter.class.getName());

    root.addFilterDef(filterDef);

    FilterMap filterMap = new FilterMap();
    filterMap.setFilterName(RemoteIpFilter.class.getName());
    filterMap.addURLPatternDecoded("*");
    root.addFilterMap(filterMap);

    MockHttpServlet mockServlet = new MockHttpServlet();

    Tomcat.addServlet(root, mockServlet.getClass().getName(), mockServlet);
    root.addServletMappingDecoded("/test", mockServlet.getClass().getName());

    getTomcatInstance().start();

    // TEST
    HttpURLConnection httpURLConnection = (HttpURLConnection) new URL(
            "http://localhost:" + tomcat.getConnector().getLocalPort() +
            "/test").openConnection();
    String expectedRemoteAddr = "my-remote-addr";
    httpURLConnection.addRequestProperty("x-forwarded-for", expectedRemoteAddr);
    httpURLConnection.addRequestProperty("x-forwarded-proto", "https");

    // VALIDATE
    Assert.assertEquals(HttpURLConnection.HTTP_OK, httpURLConnection.getResponseCode());
    HttpServletRequest request = mockServlet.getRequest();
    Assert.assertNotNull(request);

    // VALIDATE X-FORWARDED-FOR
    Assert.assertEquals(expectedRemoteAddr, request.getRemoteAddr());
    Assert.assertEquals(expectedRemoteAddr, request.getRemoteHost());

    // VALIDATE X-FORWARDED-PROTO
    Assert.assertTrue(request.isSecure());
    Assert.assertEquals("https", request.getScheme());
    Assert.assertEquals(443, request.getServerPort());
}
 

@Override
public void addFilterMap(FilterMap filterMap) {
    // NO-OP
}
 

@Override
public void addFilterMapBefore(FilterMap filterMap) {
    // NO-OP
}
 

@Override
public FilterMap[] findFilterMaps() {
    return null;
}