sourceWithFileSuffixForProject("java", "impl", "class F {}")
        sourceWithFileSuffixForProject("groovy", "impl", "class G {}")
        run ":impl:compileGroovy"

        when:
        aClass.text = "class A { void m1() {}; void m2() {}; }"
        eClass.text = "class E { boolean isCacheEnabled = D.cache; garbage }"

    <module name="TreeWalker">
        <module name="TypeName"/>
    </module>
</module>
        """
    }

    private void badCode() {
        file("src/main/java/org/gradle/class1.java") << "package org.gradle; class class1 { }"
    }

    private void defaultLocale(String defaultLocale) {
        executer.withDefaultLocale(new Locale(defaultLocale))
    }

        """

        file("src/main/java/org/gradle/ruleusing/Class1.java") << breakingDefaultRulesCode()

        expect:
        fails(":pmdMain")
        errorOutput.contains("PMD rule violations were found")
    }

    private static breakingDefaultRulesCode() {
        """
            package org.gradle.ruleusing;

            public final class Class1 {

                void foo() {
                   try {

import java.lang.reflect.Type;

class TypeStringFormatter {

    static String format(Type type) {
        if (type instanceof Class) {
            Class<?> aClass = (Class) type;
            Class<?> enclosingClass = aClass.getEnclosingClass();
            if (enclosingClass != null) {
                return format(enclosingClass) + "$" + aClass.getSimpleName();
            } else {

        Class<?> aClass = readClass();
        ObjectStreamClass descriptor = ObjectStreamClass.lookupAny(aClass);
        if (descriptor == null) {
            throw new ClassNotFoundException(aClass.getName());
        }
        return descriptor;
    }

    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {

			},
		},

		"any": {
			class:           class1,
			classParameters: classParametersEmpty,
			claimParameters: claimParametersAny,

			expectNodeResults: nodeResults{
				node1: {isSuitable: true, driverName: driver1, allocation: node1Allocation},
			},
		},

		"missing-model": {
			class:           class1,
			classParameters: classParametersEmpty,

                <ruleset-ref path='rulesets/naming.xml'/>
            </ruleset>
        """
        projectDir.file("src/main/groovy/org/gradle/Class1.groovy") << """
            package org.gradle

            class Class1 {
                public static final int constant = 1
                public boolean is() { return true; }
            }
        """

### Criando uma classe `Enum`

Importe `Enum` e crie uma sub-classe que herde de `str` e de `Enum`.

Por herdar de `str` a documentação da API vai ser capaz de saber que os valores devem ser do tipo `string` e assim ser capaz de mostrar eles corretamente.

Assim, crie atributos de classe com valores fixos, que serão os valores válidos disponíveis.

            System.setProperty("java.security.manager", securityManagerType);
            SecurityManager securityManager;
            try {
                Class<?> aClass = systemClassLoader.loadClass(securityManagerType);
                securityManager = (SecurityManager) JavaReflectionUtil.newInstance(aClass);
            } catch (Exception e) {

     */
    public static <T> Transformer<Class<T>, T> type() {
        return new Transformer<Class<T>, T>() {
            @Override
            public Class<T> transform(T original) {
                @SuppressWarnings("unchecked")
                Class<T> aClass = (Class<T>) original.getClass();
                return aClass;
            }
        };
    }