import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.TypeElement;
import java.util.Set;

/**
 * An isolating processor must provide exactly one originating element
 * for each file it generates.
 */
public class IsolatingProcessor extends DelegatingProcessor {

            project(':c') {
                configurations {
                    processor
                }
                dependencies {
                    implementation project(':a')
                    processor project(':b')
                }
                ${language.compileTaskName}.options.annotationProcessorPath = configurations.processor
                task run(type: JavaExec) {
                    mainClass = 'TestApp'

    /**
     * Artifact type name for a JAR file that can be placed either on the annotation processor class-path
     * or module-path. The path (classes or modules) is chosen by the plugin, possibly using heuristic rules.
     */
    String PROCESSOR = "processor";

    /**
     * Artifact type name for a JAR file to unconditionally place on the annotation processor class-path.
     * If the JAR is modular, its module information are ignored.
     */

import org.gradle.internal.instrumentation.processor.codegen.HasFailures;
import org.gradle.internal.instrumentation.processor.codegen.RequestGroupingInstrumentationClassSourceGenerator;
import org.gradle.internal.instrumentation.processor.codegen.SignatureUtils;
import org.gradle.internal.instrumentation.processor.codegen.TypeUtils;

        declaration: FirDeclaration,
        processor: (FirCallableDeclaration) -> Unit
    ) = when (declaration) {
        is FirSimpleFunction -> processOverriddenFunctions(declaration.symbol) { symbol ->
            processor.invoke(symbol.fir)
            ProcessorAction.NEXT
        }
        is FirProperty -> processOverriddenProperties(declaration.symbol) { symbol ->
            processor.invoke(symbol.fir)
            ProcessorAction.NEXT

                IncrementalCompileSourceProcessor processor = incrementalCompileFilesFactory.files(previousCompileState);
                for (File sourceFile : sourceFiles) {
                    processor.processSource(sourceFile);
                }
                return processor.getResult();
            }

            @Override

import static org.gradle.internal.instrumentation.processor.codegen.groovy.ParameterMatchEntry.Kind.PARAMETER;
import static org.gradle.internal.instrumentation.processor.codegen.groovy.ParameterMatchEntry.Kind.RECEIVER;
import static org.gradle.internal.instrumentation.processor.codegen.groovy.ParameterMatchEntry.Kind.RECEIVER_AS_CLASS;
import static org.gradle.internal.instrumentation.processor.codegen.groovy.ParameterMatchEntry.Kind.VARARG;

import org.gradle.internal.instrumentation.processor.codegen.InstrumentationCodeGenerator.GenerationResult.CodeFailures;
import org.gradle.internal.instrumentation.processor.codegen.InstrumentationResourceGenerator.GenerationResult.CanGenerateResource;
import org.gradle.internal.instrumentation.processor.codegen.InstrumentationResourceGenerator.GenerationResult.ResourceFailures;

import javax.annotation.processing.Filer;

import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.TypeElement;
import java.util.Set;

/**
 * An annotation processor which can decide whether it is isolating, aggregating or non-incremental at runtime.

    void setup() {
        project.ext.sourceCompatibility = "1.7"
    }

    void "creates test class processor"() {
        when:
        def framework = createFramework()
        def processor = framework.getProcessorFactory().create(Mock(IdGenerator), Mock(ActorFactory), Mock(Clock))

        then:
        processor instanceof TestNGTestClassProcessor
        framework.detector
    }