* configured timeouts, authentication, and request headers.
     */
    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initializing {}", ApiExtractor.class.getName());
        }

        // httpclient
        final org.apache.http.client.config.RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();

                }
            }
            throw new ChildUrlsException(requestDataSet, this.getClass().getName() + "#process");
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

                            responseData.setMimeType(mimeTypeHelper.getContentType(is, file.getName()));
                        } catch (final Exception e) {
                            responseData.setMimeType(mimeTypeHelper.getContentType(null, file.getName()));
                        }
                    } else {
                        if (logger.isDebugEnabled()) {

    protected CookieStore cookieStore = new BasicCookieStore();

    /** HTTP client connection manager */
    protected HttpClientConnectionManager clientConnectionManager;

    /** DNS resolver for hostname resolution */
    protected DnsResolver dnsResolver = new IdnDnsResolver();

    /** Map of authentication scheme providers */
    protected Map<String, AuthSchemeProvider> authSchemeProviderMap;

        if (dataClass == null) {
            // check transformer name
            if (!getName().equals(accessResultData.getTransformerName())) {
                throw new CrawlerSystemException("Transformer is invalid. Use " + accessResultData.getTransformerName()
                        + ". This transformer is " + getName() + ".");
            }

            final byte[] data = accessResultData.getData();

                    logger.debug("Using {} for detected MIME type {}, not {}", extractor.getClass().getName(), detectedMimeType, mimeType);
                }
            } else if (logger.isDebugEnabled()) {
                logger.debug("Using {} for MIME type {}", extractor.getClass().getName(), mimeType);
            }

            if (maxContentLength < 0) {

        assertTrue(stackTrace.length > 0);

        // First element should be from this test class
        StackTraceElement firstElement = stackTrace[0];
        assertEquals(this.getClass().getName(), firstElement.getClassName());
        assertEquals("test_stackTrace", firstElement.getMethodName());
    }

    /**
     * Test stack trace with cause
     */
    public void test_stackTraceWithCause() {

    public Object getData(final AccessResultData<?> accessResultData) {
        // check transformer name
        if (!getName().equals(accessResultData.getTransformerName())) {
            throw new CrawlerSystemException(
                    "Transformer is invalid. Use " + accessResultData.getTransformerName() + ". This transformer is " + getName() + ".");
        }

        final byte[] data = accessResultData.getData();
        if (data == null) {

        if (parentThread != null) {
            try {
                parentThread.join(millis);
            } catch (final InterruptedException e) {
                logger.warn("Interrupted job at {}", parentThread.getName());
            }
        }
    }

    /**
     * Cleans up the crawled data for a given session.
     * Deletes URL queue data and access result data, and clears the URL filter.

        } catch (NullPointerException e) {
            // Expected
        }
    }

    /**
     * Test name method
     */
    public void test_name() {
        assertEquals("INITIALIZING", CrawlerStatus.INITIALIZING.name());
        assertEquals("RUNNING", CrawlerStatus.RUNNING.name());
        assertEquals("DONE", CrawlerStatus.DONE.name());
    }

    /**