@Before
public void setUp() throws Exception {
    reactor = new NioReactor();

    crusher = TcpCrusherBuilder.builder()
            .withReactor(reactor)
            .withBindAddress("127.0.0.1",CrushER_PORT)
            .withConnectAddress(REMOTE_HOST,REMOTE_PORT)
            .buildAndopen();

    DnsResolver dnsResolver = new SystemDefaultDnsResolver() {
        @Override
        public InetAddress[] resolve(final String host) throws UnkNownHostException {
            if (host.equalsIgnoreCase(REMOTE_HOST)) {
                return new InetAddress[] { InetAddress.getByAddress(new byte[] {127,1}) };
            } else {
                return super.resolve(host);
            }
        }
    };

    httpconnectionFactory<HttpRoute,ManagedHttpClientConnection> httpconnectionFactory =
            new ManagedHttpClientConnectionFactory();

    Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
            .register("http",PlainConnectionSocketFactory.INSTANCE)
            .build();

    PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(
            socketFactoryRegistry,httpconnectionFactory,dnsResolver);

    http = HttpClients.createMinimal(connectionManager);
}

private static DnsResolver prepareProxiedDnsResolver() {
    return new SystemDefaultDnsResolver() {
        @Override
        public InetAddress[] resolve(String host) throws UnkNownHostException {
            if (host.equalsIgnoreCase("sushi-shop.test")) {
                return new InetAddress[]{InetAddress.getByName("127.0.0.1")};
            } else {
                return super.resolve(host);
            }
        }
    };
}

private CloseableHttpClient createHttpClient() throws NSPException {
    try {
        initSocketFactory();

        DnsResolver dnsResolver = new SystemDefaultDnsResolver() {
            public InetAddress[] resolve(String host)
                    throws UnkNownHostException {
                if (host.equalsIgnoreCase("localhost")) {
                    return new InetAddress[] { InetAddress
                            .getByAddress(new byte[] { 127,1 }) };
                }

                return super.resolve(host);
            }
        };
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(
                this.socketFactoryRegistry,dnsResolver);

        SocketConfig socketConfig = SocketConfig.custom()
                .setTcpNoDelay(true).setSoKeepAlive(true).setSoLinger(0)
                .setSoReuseAddress(true).build();

        connManager.setDefaultSocketConfig(socketConfig);

        ConnectionConfig connectionConfig = ConnectionConfig.custom()
                .setCharset(Consts.UTF_8).build();
        connManager.setDefaultConnectionConfig(connectionConfig);
        connManager.setConnectionConfig(new HttpHost("localhost",80),ConnectionConfig.DEFAULT);

        connManager.setMaxTotal(this.mMaxConnections);

        if ((this.mMaxConnections <= this.mConnectionsPerRoute)
                && (this.mMaxConnections > 0)) {
            this.mConnectionsPerRoute = this.mMaxConnections;
        }

        connManager.setDefaultMaxPerRoute(this.mConnectionsPerRoute);

        connManager.setMaxPerRoute(new HttpRoute(new HttpHost("localhost",80)),100);

        CloseableHttpClient httpclient = HttpClients
                .custom()
                .setConnectionManager(connManager)
                .setDefaultRequestConfig(
                        RequestConfig.copy(defaultRequestConfig).build())
                .build();

        return ((CloseableHttpClient) new WeakReference(httpclient).get());
    } catch (Exception e) {
        throw new NSPException(2,"Service unavailable.",e);
    }
}

protected ExecCallbackAsyncREST<HttpResponse> buildAsyncclient(RESTPool pool) throws IOException {
    SSLContext sslContext;
    try {
        sslContext = SSLContext.getDefault();
    } catch (NoSuchAlgorithmException e) {
        throw new IOException(e);
    }

    Registry<SchemeIOSessionStrategy> socketRegistry = RegistryBuilder.<SchemeIOSessionStrategy>create()
            .register("http",NoopIOSessionStrategy.INSTANCE)
            .register("https",new SSLIOSessionStrategy(sslContext,NoopHostnameVerifier.INSTANCE))
            .build();

    IOReactorConfig socketConfig = IOReactorConfig.custom()
            .setIoThreadCount(pool.getReactorThreadCount())
            .setSoTimeout(new Long(pool.getSocketTimeout()).intValue())
            .setTcpNoDelay(true)
            .setSoKeepAlive(true)
            .setSelectInterval(REACTOR_SELECT_INTERVAL)
            .build();

    ConnectionConfig connectionConfig = ConnectionConfig.custom()
            .setCharset(StandardCharsets.UTF_8)
            .setMalformedInputAction(CodingErrorAction.IGnorE)
            .setUnmappableInputAction(CodingErrorAction.IGnorE)
            .build();

    RequestConfig requestConfig = RequestConfig.custom()
            .setConnectionRequestTimeout(new Long(pool.getMaxPoolWait()).intValue())
            .setConnectTimeout(new Long(pool.getConnectionTimeout()).intValue())
            .setExpectContinueEnabled(pool.expectContinue())
            .setRedirectsEnabled(false)
            .setStaleConnectionCheckEnabled(pool.getValidationOnInactivity() >= 0)
            .build();

    NhttpconnectionFactory<ManagednHttpClientConnection> connFactory = new ManagednHttpClientConnectionFactory(
            new org.apache.http.impl.nio.codecs.DefaultHttpRequestWriterFactory(),new org.apache.http.impl.nio.codecs.DefaultHttpResponseParserFactory(),HeapByteBufferAllocator.INSTANCE
    );

    //Todo set validateAfterInactivity when supported
    PoolingNHttpClientConnectionManager ccm = new PoolingNHttpClientConnectionManager(
            new DefaultConnectingIOReactor(socketConfig),connFactory,socketRegistry,new SystemDefaultDnsResolver()
    );

    ccm.setMaxTotal(pool.getMaxTotal());
    ccm.setDefaultMaxPerRoute(pool.getMaxPerRoute());
    ccm.setDefaultConnectionConfig(connectionConfig);

    HttpAsyncclientBuilder builder = HttpAsyncclients.custom()
            .setConnectionManager(ccm)
            .setDefaultRequestConfig(requestConfig)
            .setKeepAliveStrategy(DefaultConnectionKeepAliveStrategy.INSTANCE)
            .disableCookieManagement();

    IdleAsyncConnectionevictor evictor = new IdleAsyncConnectionevictor(ccm,pool.getevictorSleep(),TimeUnit.MILLISECONDS,pool.getMaxIdleTime(),TimeUnit.MILLISECONDS);

    addProxy(pool,builder);

    handleRedirects(pool,builder);

    CloseableHttpAsyncclient servClient = builder.build();

    servClient.start();

    HTTPcclientMonitor monitor = pool.hasConnectionMetrics() ? new HTTPCAsyncclientMonitor(pool.getName(),ccm) : null;

    return new HTTPCAsyncclient(servClient,evictor,monitor);
}

public void init() {

        available = new Semaphore(maxParallel(),true);

        SSLContext sslContext = SSLContexts.createSystemDefault();
        HostnameVerifier hostnameVerifier = new DefaultHostnameVerifier();

        Registry<ConnectionSocketFactory> sessionStrategyRegistry = RegistryBuilder.<ConnectionSocketFactory> create()
                .register("http",PlainConnectionSocketFactory.getSocketFactory())
                .register("https",new SSLConnectionSocketFactory(sslContext,hostnameVerifier)).build();

        DnsResolver dnsResolver = new SystemDefaultDnsResolver() {
            @Override
            public InetAddress[] resolve(final String host) throws UnkNownHostException {
                if (host.equalsIgnoreCase("localhost")) {
                    return new InetAddress[] { InetAddress.getByAddress(new byte[] { 127,1 }) };
                } else {
                    return new InetAddress[] { nameResolver().resolve(host) };
                }
            }
        };

        // Create a connection manager with custom configuration.
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(sessionStrategyRegistry,dnsResolver);

        // Create message constraints
        MessageConstraints messageConstraints = MessageConstraints.custom().setMaxHeaderCount(maxHeaderCount).setMaxLineLength(maxLineLength).build();

        // Create connection configuration
        ConnectionConfig connectionConfig = ConnectionConfig.custom().setMalformedInputAction(CodingErrorAction.IGnorE)
                .setUnmappableInputAction(CodingErrorAction.IGnorE).setCharset(Consts.UTF_8).setMessageConstraints(messageConstraints).build();
        connManager.setDefaultConnectionConfig(connectionConfig);

        // Configure total max or per route limits for persistent connections
        // that can be kept in the pool or leased by the connection manager.
        connManager.setMaxTotal(maxPersistentConnections());
        connManager.setDefaultMaxPerRoute(maxPersistentConnections());

        // Todo
        // Use custom credentials provider if necessary.
        // CredentialsProvider credentialsProvider = new
        // BasicCredentialsProvider();

        // Create global request configuration
        defaultRequestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.DEFAULT).setExpectContinueEnabled(true).setStaleConnectionCheckEnabled(true)
                .setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM,AuthSchemes.DIGEST))
                .setProxyPreferredAuthSchemes(Arrays.asList(AuthSchemes.BASIC)).setMaxRedirects(maxRedirects()).setSocketTimeout(socketTimeout())
                .setConnectTimeout(connectTimeout()).setConnectionRequestTimeout(requestTimeOut()).setRedirectsEnabled(followRedirects()).build();

        // Create an HttpClient with the given custom dependencies and
        // configuration.
        client = HttpClients.custom().setConnectionManager(connManager)
        // .setDefaultCredentialsProvider(credentialsProvider)
                .setDefaultRequestConfig(defaultRequestConfig).build();
    }

private HttpClient createHttpClient(FDSClientConfiguration config) {
  RequestConfig requestConfig = RequestConfig.custom()
      .setConnectTimeout(config.getConnectionTimeoutMs())
      .setSocketTimeout(config.getSocketTimeoutMs())
      .build();

  RegistryBuilder<ConnectionSocketFactory> registryBuilder = RegistryBuilder.create();
  registryBuilder.register("http",new ConnectionInfoRecorderSocketFactory(
      new PlainConnectionSocketFactory()));

  if (config.isHttpsEnabled()) {
    SSLContext sslContext = SSLContexts.createSystemDefault();
    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
        sslContext,SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
    registryBuilder.register("https",new ConnectionInfoRecorderSocketFactory(sslsf));
  }
  ipBlackList = new TimeBasedIpAddressBlackList(config.getIpAddressNegativeDurationMillsec());
  connectionManager = new PoolingHttpClientConnectionManager(registryBuilder.build(),null,new RoundRobinDNSResolver(new InternalSiteBlackListDNSResolver(ipBlackList,this.dnsResolver == null ?
              SystemDefaultDnsResolver.INSTANCE : this.dnsResolver)),config.getHTTPKeepAliveTimeoutMS(),TimeUnit.MILLISECONDS);
  connectionManager.setDefaultMaxPerRoute(config.getMaxConnection());
  connectionManager.setMaxTotal(config.getMaxConnection());

  FDSBlackListEnabledHostChecker fdsBlackListEnabledHostChecker = new FDSBlackListEnabledHostChecker();
  retryHandler = new InternalIpBlackListRetryHandler(config.getRetryCount(),ipBlackList,fdsBlackListEnabledHostChecker);
  HttpClient httpClient = HttpClients.custom()
      .setRetryHandler(retryHandler)
      .setServiceUnavailableRetryStrategy(new ServiceUnavailablednSBlackListStrategy(
          config.getRetryCount(),config.getRetryIntervalMilliSec(),fdsBlackListEnabledHostChecker))
      .setConnectionManager(connectionManager)
      .setDefaultRequestConfig(requestConfig)
      .build();
  return httpClient;
}

public DnsResolverWithTimeout() {
    this(DNS_RESOLVE_EXECUTOR,new SystemDefaultDnsResolver(),getDnsTimeout());
}

/**
 * Utility method for Consumers to process API method invocation result.
 * @param consumer Consumer that wants to process results.
 * @param result result of API method invocation.
 * @param splitResult true if the Consumer wants to split result using {@link org.apache.camel.util.component.ResultInterceptor#splitResult(Object)} method.
 * @param <T> Consumer class that extends DefaultConsumer and implements {@link org.apache.camel.util.component.ResultInterceptor}.
 * @return number of result exchanges processed.
 * @throws Exception on error.
 */
public static <T extends DefaultConsumer & ResultInterceptor> int getResultsProcessed(
    T consumer,Object result,boolean splitResult) throws Exception {

    // process result according to type
    if (result != null && splitResult) {
        // try to split the result
        final Object resultArray = consumer.splitResult(result);

        if (resultArray != result && resultArray.getClass().isArray()) {
            // create an exchange for every element
            final int length = Array.getLength(resultArray);
            for (int i = 0; i < length; i++) {
                processResult(consumer,result,Array.get(resultArray,i));
            }
            return length;
        }
    }

    processResult(consumer,result);
    return 1; // number of messages polled
}

private static <T extends DefaultConsumer & ResultInterceptor> void processResult(T consumer,Object methodResult,Object result)
    throws Exception {

    Exchange exchange = consumer.getEndpoint().createExchange();
    exchange.getIn().setBody(result);

    consumer.interceptResult(methodResult,exchange);
    try {
        // send message to next processor in the route
        consumer.getProcessor().process(exchange);
    } finally {
        // log exception if an exception occurred and was not handled
        final Exception exception = exchange.getException();
        if (exception != null) {
            consumer.getExceptionHandler().handleException("Error processing exchange",exchange,exception);
        }
    }
}

@Override
public void process(final Exchange exchange) throws Exception {
    final int count = getHeaderValue(exchange,HEADER_IteraTIONS);
    final int threads = getHeaderValue(exchange,HEADER_THREADS);
    PerformanceTestEndpoint endpoint = (PerformanceTestEndpoint)getEndpoint();
    if (endpoint != null) {
        final DefaultConsumer consumer = (DefaultConsumer)endpoint.getConsumer();
        ExecutorService executor = exchange.getContext().getExecutorServiceManager().newFixedThreadPool(this,"perf",threads);
        CompletionService<Exchange> tasks = new ExecutorCompletionService<Exchange>(executor);

        // StopWatch watch = new StopWatch();  // if we want to clock how long it takes
        for (int i = 0; i < count; i++) {
            tasks.submit(new Callable<Exchange>() {
                @Override
                public Exchange call() throws Exception {
                    Exchange exch = ExchangeHelper.createcopy(exchange,false);
                    try {
                        consumer.getProcessor().process(exch);
                    } catch (final Exception e) {
                        exch.setException(e);
                    }
                    return exch;
                }
            });
        }

        for (int i = 0; i < count; i++) {
            // Future<Exchange> result = tasks.take();
            tasks.take();       // wait for all exchanges to complete
        }
    }
}

@Override
public Consumer createConsumer(Processor processor) throws Exception {
    return new DefaultConsumer(this,processor) {
        @Override
        protected void doStart() throws Exception {
            processors.add(getProcessor());
        }

        @Override
        protected void doStop() throws Exception {
            processors.remove(getProcessor());                   
        }
    };
}

protected Set<DefaultConsumer> getConsumers() {
    return consumers;
}

public void testFindByFilterPackageInJarUrl() throws Exception {
    ClassLoader savedClassLoader = null;
    try {
        savedClassLoader = Thread.currentThread().getContextClassLoader();
        URL url = getClass().getResource("/package_scan_test.jar");

        URL urls[] = {new URL("jar:" + url.toString() + "!/")};
        urlclassloader classLoader = new urlclassloader(urls,savedClassLoader);

        Thread.currentThread().setContextClassLoader(classLoader);

        // recreate resolver since we mess with context class loader
        resolver = new DefaultPackageScanClassResolver();

        filter.addIncludePattern("a.*.c.*");
        resolver.addFilter(filter);
        Set<Class<?>> scanned = resolver.findByFilter(filter,"a.b.c");
        assertEquals(1,scanned.size());
        assertEquals("class a.b.c.Test",scanned.iterator().next().toString());            
    } finally {
        if (savedClassLoader != null) {
            Thread.currentThread().setContextClassLoader(savedClassLoader);
        } 
    }
}

public void testFindByFilterPackageInJarUrlWithPlusChars() throws Exception {
    ClassLoader savedClassLoader = null;
    try {
        savedClassLoader = Thread.currentThread().getContextClassLoader();
        URL url = getClass().getResource("/package+scan+test.jar");

        URL urls[] = {new URL("jar:" + url.toString() + "!/")};
        urlclassloader classLoader = new urlclassloader(urls,scanned.iterator().next().toString());
    } finally {
        if (savedClassLoader != null) {
            Thread.currentThread().setContextClassLoader(savedClassLoader);
        }
    }
}

@Test
public void testLoadModels() throws Exception {
    AnnotationModelLoader loader = new AnnotationModelLoader(new DefaultPackageScanClassResolver());
    Set<Class<?>> classes = loader.loadModels("org.apache.camel.dataformat.bindy.model.complex.twoclassesandonelink");
    assertNotNull("The findForFormattingOptions classes should not be null ",classes);
    assertEquals("There should have 3 classes",3,classes.size());
    assertTrue(classes.contains(Client.class));
    assertTrue(classes.contains(Order.class));
    assertTrue(classes.contains(Security.class));
}

public void testSetAcceptableSchema() throws Exception {
    DefaultPackageScanClassResolver resolver = (DefaultPackageScanClassResolver)context.getPackageScanClassResolver();
    assertNotNull(resolver);
    // just check the accept schema
    assertTrue("We should accept the test:!",resolver.isAcceptableScheme("test://test"));
    assertTrue("We should accept the test2:!",resolver.isAcceptableScheme("test2://test"));

}

private Set<Class<?>> discoverJaxbClasses() {
    PackageScanClassResolver resolver = new DefaultPackageScanClassResolver();
    String[] packages = Constants.JAXB_CONTEXT_PACKAGES.split(":");
    return resolver.findAnnotated(XmlAccessorType.class,packages);
}

@Before
public void init() throws Exception {
    converter = new DefaultTypeConverter(new DefaultPackageScanClassResolver(),new ReflectionInjector(),new DefaultFactoryFinderResolver().resolveDefaultFactoryFinder(new DefaultClassResolver()));
    ServiceHelper.startService(converter);
}

protected DefaultTypeConverter createRegistry() {
    // base the osgi type converter on the default type converter
    DefaultTypeConverter answer = new DefaultTypeConverter(new DefaultPackageScanClassResolver() {
        @Override
        public Set<ClassLoader> getClassLoaders() {
            // we don't need any classloaders as we use Osgi service tracker instead
            return Collections.emptySet();
        }
    },injector,factoryFinder);

    // inject CamelContext
    answer.setCamelContext(camelContext);

    try {
        // only load the core type converters,as Osgi activator will keep track on bundles
        // being installed/uninstalled and load type converters as part of that process
        answer.loadCoreTypeConverters();
    } catch (Exception e) {
        throw new RuntimeCamelException("Error loading CoreTypeConverter due: " + e.getMessage(),e);
    }

    // Load the type converters the tracker has been tracking
    // Here we need to use the ServiceReference to check the ranking
    ServiceReference<TypeConverterLoader>[] serviceReferences = this.tracker.getServiceReferences();
    if (serviceReferences != null) {
        ArrayList<ServiceReference<TypeConverterLoader>> servicesList = 
            new ArrayList<ServiceReference<TypeConverterLoader>>(Arrays.asList(serviceReferences));
        // Just make sure we install the high ranking fallback converter at last
        Collections.sort(servicesList);
        for (ServiceReference<TypeConverterLoader> sr : servicesList) {
            try {
                LOG.debug("loading type converter from bundle: {}",sr.getBundle().getSymbolicName());
                ((TypeConverterLoader)this.tracker.getService(sr)).load(answer);
            } catch (Throwable t) {
                throw new RuntimeCamelException("Error loading type converters from service: " + sr + " due: " + t.getMessage(),t);
            }
        }
    }

    LOG.trace("Created TypeConverter: {}",answer);
    return answer;
}

public void setUp() throws Exception {
    super.setUp();
    resolver = new DefaultPackageScanClassResolver();
    annotations.add(org.apache.camel.spring.scan.ScannableOne.class);
    annotations.add(org.apache.camel.spring.scan.ScannableTwo.class);
}

@Override
public Property getItemProperty(Object id) {
    final String propertyName = id.toString();
    if (getDynaBean().getDynaClass().getDynaProperty(propertyName) == null) {
        DefaultResolver defaultResolver = new DefaultResolver();
        if (!(defaultResolver.hasnested(propertyName) || defaultResolver.
                isIndexed(propertyName))) {
            // Lazy query container detects some debug properties via 
            // Item!! 
            return null;
        }
    }
    DynaProperty prop = propertyIdToProperty.get(id);
    if (prop == null) {
        prop = new DynaProperty(propertyName);
        propertyIdToProperty.put(id,prop);
    }
    return prop;
}

/**
 * Configure the {@link Resolver} implementation used by BeanUtils.
 * <p>
 * The {@link Resolver} handles the <i>property name</i>
 * expressions and the implementation in use effectively
 * controls the dialect of the <i>expression language</i>
 * that BeanUtils recongnises.
 * <p>
 * {@link DefaultResolver} is the default implementation used.
 *
 * @param resolver The property expression resolver.
 * @since 1.8.0
 */
public void setResolver(final Resolver resolver) {
    if (resolver == null) {
        this.resolver = new DefaultResolver();
    } else {
        this.resolver = resolver;
    }
}

/**
* Create the processor with the following interceptors:
* <ul>
* <li>{@link RequestDefaultHeaders}</li>
* <li>{@link RequestContent}</li>
* <li>{@link RequestTargetHost}</li>
* <li>{@link RequestClientConnControl}</li>
* <li>{@link RequestUserAgent}</li>
* <li>{@link RequestExpectContinue}</li>
* <li>{@link RequestAddCookies}</li>
* <li>{@link ResponseProcessCookies}</li>
* <li>{@link RequestAuthCache}</li>
* <li>{@link RequestTargetAuthentication}</li>
* <li>{@link RequestProxyAuthentication}</li>
* </ul>
* <p>
* @return the processor with the added interceptors.
*/
@Override
protected BasicHttpProcessor createHttpProcessor() {
    BasicHttpProcessor httpproc = new BasicHttpProcessor();
    httpproc.addInterceptor(new RequestDefaultHeaders());
    // required protocol interceptors
    httpproc.addInterceptor(new RequestContent());
    httpproc.addInterceptor(new RequestTargetHost());
    // Recommended protocol interceptors
    httpproc.addInterceptor(new RequestClientConnControl());
    httpproc.addInterceptor(new RequestUserAgent());
    httpproc.addInterceptor(new RequestExpectContinue());
    // HTTP state management interceptors
    httpproc.addInterceptor(new RequestAddCookies());
    httpproc.addInterceptor(new ResponseProcessCookies());
    // HTTP authentication interceptors
    httpproc.addInterceptor(new RequestAuthCache());
    httpproc.addInterceptor(new RequestTargetAuthentication());
    httpproc.addInterceptor(new RequestProxyAuthentication());
    return httpproc;
}

private static HttpClientBuilder _getApacheKissHttpClientBuilder() {

        return HttpClients.custom()
                .addInterceptorFirst(new RequestDefaultHeaders())
                .addInterceptorFirst(new RequestContent())
                .addInterceptorFirst(new RequestTargetHost())
                .addInterceptorFirst(new RequestClientConnControl())
                .addInterceptorFirst(new RequestAddCookies())
                .addInterceptorFirst(new ResponseProcessCookies())
                .addInterceptorFirst(new RequestAuthCache())
                .addInterceptorLast(new HttpRequestInterceptor() {

                    @Override
                    public void process(final HttpRequest request,final HttpContext context) throws HttpException,IOException {

                        if (request.containsHeader("User-Agent")) {

                            request.removeHeaders("User-Agent");

                        }

                        if (request.containsHeader("Custom-User-Agent")) {

                            request.addHeader("User-Agent",request.getFirstHeader("Custom-User-Agent").getValue());

                            request.removeHeaders("Custom-User-Agent");
                        }
                    }

                });
    }

/**
* Create the processor with the following interceptors:
* <ul>
* <li>{@link RequestDefaultHeaders}</li>
* <li>{@link RequestContent}</li>
* <li>{@link RequestTargetHost}</li>
* <li>{@link RequestClientConnControl}</li>
* <li>{@link RequestUserAgent}</li>
* <li>{@link RequestExpectContinue}</li>
* <li>{@link RequestAddCookies}</li>
* <li>{@link ResponseProcessCookies}</li>
* <li>{@link RequestAuthCache}</li>
* <li>{@link RequestTargetAuthentication}</li>
* <li>{@link RequestProxyAuthentication}</li>
* </ul>
* <p>
* @return the processor with the added interceptors.
*/
@Override
protected BasicHttpProcessor createHttpProcessor() {
    final BasicHttpProcessor httpproc = new BasicHttpProcessor();
    httpproc.addInterceptor(new RequestDefaultHeaders());
    // required protocol interceptors
    httpproc.addInterceptor(new RequestContent());
    httpproc.addInterceptor(new RequestTargetHost());
    // Recommended protocol interceptors
    httpproc.addInterceptor(new RequestClientConnControl());
    httpproc.addInterceptor(new RequestUserAgent());
    httpproc.addInterceptor(new RequestExpectContinue());
    // HTTP state management interceptors
    httpproc.addInterceptor(new RequestAddCookies());
    httpproc.addInterceptor(new ResponseProcessCookies());
    // HTTP authentication interceptors
    httpproc.addInterceptor(new RequestAuthCache());
    httpproc.addInterceptor(new RequestTargetAuthentication());
    httpproc.addInterceptor(new RequestProxyAuthentication());
    return httpproc;
}

@Override
protected BasicHttpProcessor createHttpProcessor() {
    BasicHttpProcessor httpproc = new BasicHttpProcessor();
    httpproc.addInterceptor(new RequestDefaultHeaders());
    // required protocol interceptors
    httpproc.addInterceptor(new RequestContent());
    httpproc.addInterceptor(new RequestTargetHost());
    // Recommended protocol interceptors
    httpproc.addInterceptor(new RequestClientConnControl());
    httpproc.addInterceptor(new RequestUserAgent());
    httpproc.addInterceptor(new RequestExpectContinue());
    // HTTP state management interceptors
    httpproc.addInterceptor(new RequestAddCookies());
    httpproc.addInterceptor(new ResponseProcessCookies());
    // HTTP authentication interceptors
    httpproc.addInterceptor(new RequestTargetAuthentication());
    httpproc.addInterceptor(new RequestProxyAuthentication());
    return httpproc;
}