}
    }

    /**
     * Gets the content of the response using the provided parser function.
     *
     * @param <T> the type of the parsed content.
     * @param parser the function to parse the content.
     * @return the parsed content.
     */
    public <T> T getContent(final Function<CurlResponse, T> parser) {
        return parser.apply(this);
    }

    /**
     * Gets the content of the response as a string.

                is.setEncoding(responseData.getCharSet());
            }
            parser.parse(is);
        } catch (final Exception e) {
            throw new CrawlingAccessException("Could not parse " + responseData.getUrl(), e);
        }

        final Document document = parser.getDocument();

        processMetaRobots(responseData, resultData, document);

        return OptionalThing.empty();
    }

    /**
     * Configuration class that holds parsed configuration values for a field.
     * This class parses pipe-separated configuration values and provides methods
     * to check for specific configuration options.
     */
    public static class Config {

        /**
         * Array of parsed configuration values split by pipe character and trimmed.
         */

  <modelVersion>4.0.0</modelVersion>

  <groupId>inheritance</groupId>
  <artifactId>parent</artifactId>
  <version>11-SNAPSHOT</version>

  <name>Model urls inheritance test parent</name>
  <description>Most classical case: child in direct subdirectory with directory name == child artifactId</description>

  <modules>
    <module>child-artifact-id</module>

        try {
            final StandardQueryParser parser = new StandardQueryParser();
            parser.setDefaultOperator(StandardQueryConfigHandler.Operator.AND);

            // Parse with the first field if available, otherwise use "default"
            String defaultField = fields != null && fields.length > 0 ? fields[0] : "default";
            termQueryList = getTermQueryList(parser.parse(q, defaultField), fields);

		if err != nil {
			return nil, err
		}

		qosEnv := target.EnvMQTTQoS
		if k != config.Default {
			qosEnv = qosEnv + config.Default + k
		}

		// Parse uint8 value
		qos, err := strconv.ParseUint(env.Get(qosEnv, kv.Get(target.MqttQoS)), 10, 8)
		if err != nil {
			return nil, err
		}

		topicEnv := target.EnvMQTTTopic
		if k != config.Default {

    @Resource
    protected CrawlerContainer crawlerContainer;

    /** Map of parser features to configure the DOM parser. */
    protected Map<String, String> featureMap = new HashMap<>();

    /** Map of parser properties to configure the DOM parser. */
    protected Map<String, String> propertyMap = new HashMap<>();

     * @param pomPath the path to the POM file
     * @return the parsed Document
     * @throws IOException if there's an error reading the file
     * @throws DomTripException if there's an error parsing the XML
     */
    private static Document loadPom(Path pomPath) throws IOException, DomTripException {
        String content = Files.readString(pomPath);
        return new Parser().parse(content);
    }

    /**

        <configuration>
          <defaults>
            <parent-only>parent</parent-only>
            <parent>parent</parent>
          </defaults>
          <appends>
            <parent-only>parent</parent-only>
            <parent>parent</parent>
          </appends>
          <overrides>
            <parent-only>parent</parent-only>
            <parent>parent</parent>
          </overrides>
        </configuration>

        CommonsCliUpgradeOptions options = CommonsCliUpgradeOptions.parse(args);
        assertNotNull(options);

        // We can't easily test the help output directly, but we can verify
        // that the option is properly configured by checking if it parses
        String[] pluginsArgs = {"apply", "--plugins"};
        CommonsCliUpgradeOptions pluginsOptions = CommonsCliUpgradeOptions.parse(pluginsArgs);