}
                extractData.putValue("Content-Length", Long.toString(contentLength));

                final String[] names = metadata.names();
                Arrays.sort(names);
                for (final String name : names) {
                    extractData.putValues(name, metadata.getValues(name));
                }

                if (postFilter != null) {
                    InputStream in = null;

 *   <li>Dynamic passwords provided through extraction parameters</li>
 * </ul>
 *
 * <p>Passwords are matched against URLs or resource names using regular expression patterns.
 * The extractor first tries to match against the URL, then falls back to the resource name if available.
 *
 * @author shinsuke
 */
public abstract class PasswordBasedExtractor extends AbstractExtractor {

 * This class handles the registration and loading of crawler client factories and their associated clients.
 * <p>
 * The class maintains a mapping between regular expressions and component names, and manages a list
 * of crawler client factories with a configurable maximum size.
 * </p>
 *
 */
public class CrawlerClientCreator {
    /**
     * Constructs a new CrawlerClientCreator.
     */

     * @param extractData the extraction data
     * @param name the metadata name
     * @param value the metadata value
     */
    protected void addMetadata(final ExtractData extractData, final String name, final String value) {
        if (value != null) {
            extractData.putValue(name, value);
        }
    }

    /**

 * It allows setting a default encoding, mapping various encoding names to preferred ones,
 * and normalizing an encoding string to its preferred form or the default if no mapping is found.
 */
public class EncodingHelper {

    /** The default encoding to use when no mapping is found */
    protected String defaultEncoding;

    /** Map of encoding names to their preferred forms */

     * @param key the field name to match against
     * @param regex the regular expression pattern
     */
    public void addRule(final String key, final String regex) {
        regexMap.put(key, Pattern.compile(regex));
    }

    /**
     * Adds a compiled regular expression rule for the specified field.
     * @param key the field name to match against

        super();
    }

    /**
     * Resolves the given host name to an array of IP addresses.
     * The host name is first converted to ASCII using IDN before resolution.
     *
     * @param host the host name to resolve
     * @return an array of IP addresses for the host
     * @throws UnknownHostException if the host name cannot be resolved
     */
    @Override

        // Newline characters
        testTransformer.setName("name\nwith\nnewlines");
        assertEquals("name\nwith\nnewlines", testTransformer.getName());
    }

    /**
     * Test multiple name changes
     */
    public void test_multipleNameChanges() {
        String[] names = { "first", "second", "third", "fourth", "fifth" };

        for (String name : names) {
            testTransformer.setName(name);

     * Returns the data index name.
     * @return The data index name.
     */
    public String getDataIndex() {
        return dataIndex;
    }

    /**
     * Sets the data index name.
     * @param dataIndex The data index name.
     */
    public void setDataIndex(final String dataIndex) {
        this.dataIndex = dataIndex;
    }

    /**
     * Returns the filter index name.

        // Should handle long URLs without issues
        assertTrue(urlFilter.match(longUrl.toString()));
    }

    /**
     * Test internationalized domain names (IDN)
     */
    public void test_internationalizedDomainNames() {
        String sessionId = "test-session-021";
        urlFilter.init(sessionId);

        urlFilter.addInclude(".*日本.*");