import org.gradle.internal.fingerprint.FileNormalizer;

import java.util.Locale;

// TODO Break this up between simple normalizers and Java classpath normalizers
//      The latter should be moved to :normalization-java
public enum InputNormalizer implements FileNormalizer {
    ABSOLUTE_PATH(false),
    RELATIVE_PATH(false),
    NAME_ONLY(false),
    IGNORE_PATH(true),
    RUNTIME_CLASSPATH(true),

		prefix string
	}{
		// Mismatch
		{"a", "b"},

		// Dir requirement
		{"a", "a/"},

		// Prefix mismatch
		{"ns2", "ns"},
		{"ns2", "ns/"},
		{"中文文", "中文"},

		// Ensure no normalization is applied
		{"a/c/../b/", "a/b/"},
		{"a/", "a/b/.."},
	}
	for i, tc := range invalidTestcases {
		if hasPathPrefix(tc.s, tc.prefix) {

        if (typeAnnotation != null) {
            return typeAnnotation.annotationType();
        } else {
            Annotation normalizationAnnotation = propertyAnnotations.get(ModifierAnnotationCategory.NORMALIZATION);
            if (normalizationAnnotation != null) {
                Class<? extends Annotation> normalizationType = normalizationAnnotation.annotationType();

import org.gradle.internal.snapshot.FileSystemLocationSnapshot;
import org.gradle.internal.snapshot.FileSystemSnapshot;

import java.util.Map;

/**
 * Fingerprint files without path or content normalization.
 */
public class AbsolutePathFingerprintingStrategy extends AbstractDirectorySensitiveFingerprintingStrategy {

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.normalization.java.impl;

import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.Opcodes;

import java.util.LinkedList;
import java.util.List;

public class SortingAnnotationVisitor extends AnnotationVisitor {

[[missing_normalization_annotation]]
== Missing normalization annotation

This error occurs whenever a task or artifact transform is cacheable and that a file or file collection input property isn't declaring how it should be normalized.
Normalization tells Gradle if, for example, the absolute path of input files matter or if only the contents is relevant.

        override fun getNormalization(): InputNormalizationHandlerInternal {
            onAccess("normalization")
            return delegate.normalization
        }

        override fun normalization(configuration: Action<in InputNormalizationHandler>) {
            onAccess("normalization")
            delegate.normalization(configuration)
        }

        'validation:property-validation:missing-annotation' : 'Missing annotation',
        'validation:property-validation:missing-normalization-annotation' : 'Missing normalization',
        'validation:property-validation:nested-map-unsupported-key-type' : 'Unsupported nested map key',
        'validation:property-validation:nested-type-unsupported' : 'Nested type unsupported',

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl

import org.gradle.execution.plan.ScheduledWork
import org.gradle.normalization.internal.InputNormalizationHandlerInternal
import org.gradle.util.Path
import java.io.File


/**
 * State cached for a project.
 */
internal
sealed class CachedProjectState(
    val path: Path,

import org.gradle.exemplar.test.normalizer.OutputNormalizer;

import java.util.regex.Pattern;

/**
 * Conditionally removes the configuration cache logging from the Gradle output.
 * This normalization is only enabled if {@link #CLEAN_CONFIGURATION_CACHE_OUTPUT}
 * system property is set to {@code true}.
 * <p>
 * Most of our samples that aren't aiming to test the configuration cache itself, do not care about