val propertyName: String,
        val propertyValue: PropertyValue,
        val optional: Boolean,
        val filePropertyType: InputFilePropertyType,
        val behavior: InputBehavior,
        val normalizer: FileNormalizer?,
        val directorySensitivity: DirectorySensitivity,
        val lineEndingSensitivity: LineEndingSensitivity
    ) : RegisteredProperty()

    data class OutputFile(

import org.codelibs.fess.suggest.entity.SuggestItem;
import org.codelibs.fess.suggest.exception.SuggesterException;
import org.codelibs.fess.suggest.normalizer.AnalyzerNormalizer;
import org.codelibs.fess.suggest.normalizer.Normalizer;
import org.codelibs.fess.suggest.normalizer.NormalizerChain;
import org.codelibs.fess.suggest.settings.AnalyzerSettings;
import org.codelibs.fess.suggest.settings.SuggestSettings;

 * limitations under the License.
 */
package org.gradle.integtests.fixtures.logging

import org.gradle.exemplar.executor.ExecutionMetadata
import org.gradle.exemplar.test.normalizer.OutputNormalizer

/**
 * This normalizer converts native component paths and environment
 * information to look like macOS because samples output currently shows
 * the output for macOS and is not yet capable of adapting dynamically

    public DefaultInputFilePropertySpec(
        String propertyName,
        FileNormalizer normalizer,
        FileCollectionInternal files,
        PropertyValue value,
        InputBehavior behavior,
        DirectorySensitivity directorySensitivity,
        LineEndingSensitivity lineEndingSensitivity
    ) {
        super(propertyName, normalizer, files);
        this.behavior = behavior;

		f.Fuzz(orig)

		// normalize Structural.ValueValidation to zero values if it was nil before
		normalizer := Visitor{
			Structural: func(s *Structural) bool {
				if s.ValueValidation == nil {
					s.ValueValidation = &ValueValidation{}
					return true
				}
				return false
			},
		}
		normalizer.Visit(orig)

		kubeOpenAPI := orig.ToKubeOpenAPI()
		bs, err := json.Marshal(kubeOpenAPI)
		if err != nil {

                actionMetadata.getAnnotationHandlerFor(propertyMetadata).visitPropertyValue(propertyMetadata.getPropertyName(), PropertyValue.ABSENT, propertyMetadata, visitor);
                inputArtifactNormalizer = visitor.normalizer;
                artifactDirectorySensitivity = visitor.directorySensitivity;
                artifactLineEndingSensitivity = visitor.lineEndingSensitivity;

                    dispatch.dispatch(message);
                }
            });
        }

        @Override
        public void readAndForwardText(Normalizer normalizer) {
            executor.execute(() -> {
                while (true) {
                    String input;
                    try {
                        input = reader.readLine();

    }

    static String mirrorInitScript() {
        def mirrorConditions = MirroredRepository.values().collect { MirroredRepository mirror ->
            """
                if (normalizeUrl(repo.url) == normalizeUrl('${mirror.originalUrl}')) {
                    repo.url = '${mirror.mirrorUrl}'
                }
            """
        }.join("")
        return """

        private final FileNormalizer normalizer;
        private final DirectorySensitivity directorySensitivity;
        private final LineEndingSensitivity lineEndingSensitivity;
        private final Supplier<FileCollection> files;

        public InputFileValueSupplier(
            @Nullable Object value,
            FileNormalizer normalizer,
            DirectorySensitivity directorySensitivity,

        }

        private final UrlNormalizer normalizer;

        UrlNormalizingPostProcessor(UrlNormalizer normalizer) {
            this.normalizer = normalizer;
        }

        @Override
        public Object execute(String expression, Object value) {
            if (value != null && URL_EXPRESSIONS.contains(expression)) {
                return normalizer.normalize(value.toString());
            }