* either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.suggest.normalizer;

public interface Normalizer {
    String normalize(String text, String field, String... langs);

> Task :app:build

BUILD SUCCESSFUL in 0s
7 actionable tasks: 7 executed
""".trim()

        when:
        String normalized = outputNormalizer.normalize(input, executionMetadata)

        then:
        normalized == expected
    }

    def "successfully normalizes Scala compiler warning"() {
        given:
        String input = """
> Task :app:compileJava NO-SOURCE
> Task :app:compileScala

        tool chain: Tool chain 'clang' (Clang)
        executable file: build/exe/main/main
"""

        when:
        String normalized = outputNormalizer.normalize(input, executionMetadata)

        then:
        normalized == expected
    }

    def "successfully normalizes windows output"() {
        given:
        String input = """
> Task :components

     */
    void readAndForwardText(Normalizer normalizer);

    /**
     * Requests that bytes should be read from this process' stdin and forwarded to the daemon.
     * Does not block waiting for the input.
     */
    void readAndForwardStdin();

    interface Normalizer {
        /**
         * Validates and normalizes the given text received from the user.
         *

 */
package org.codelibs.fess.suggest.normalizer;

import java.util.ArrayList;
import java.util.List;

public class NormalizerChain implements Normalizer {
    List<Normalizer> normalizers = new ArrayList<>();

    @Override
    public String normalize(final String text, final String field, final String... langs) {
        String tmp = text;
        for (final Normalizer normalizer : normalizers) {

        settings.badword().delete(normalizer.normalize(badWord, ""));
    }

    public SuggestIndexResponse addElevateWord(final ElevateWord elevateWord, final boolean apply) {
        final String normalizedWord = normalizer.normalize(elevateWord.getElevateWord(), "");
        final List<String> normalizedReadings =
                elevateWord.getReadings().stream().map(reading -> normalizer.normalize(reading, "")).collect(Collectors.toList());

 */
package org.apache.maven.api.services.model;

public interface UrlNormalizer {

    /**
     * Normalizes the specified URL.
     *
     * @param url The URL to normalize, may be {@code null}.
     * @return The normalized URL or {@code null} if the input was {@code null}.
     */
    String normalize(String url);

import org.apache.maven.api.services.ModelBuilderRequest;

/**
 * Normalizes URLs to remove the ugly parent references "../" that got potentially inserted by URL adjustment during
 * model inheritance.
 *
 */
public interface ModelUrlNormalizer {

    /**
     * Normalizes the well-known URLs of the specified model.
     *
     * @param model The model whose URLs should be normalized, may be {@code null}.

 */

package org.gradle.integtests.fixtures.logging

import spock.lang.Specification

class DependencyInsightOutputNormalizerTest extends Specification {

    def normalizer = new DependencyInsightOutputNormalizer()

    def 'normalizes single-digit requested JDK version in "new" dependencyInsight report'() {
        given:
        def originalOutput = '''
    | Attribute Name                 | Provided | Requested    |

 * its output much. This normalizer allows to reuse the same "golden" output files when testing such
 * samples with the configuration cache enabled.
 */
public class ConfigurationCacheOutputCleaner implements OutputNormalizer {
    // The configuration of the normalizers is static (defined in the annotations), so this
    // normalizer is going to be applied everywhere. We don't want, however, to remove configuration