import java.util.stream.Collectors;

import static org.gradle.api.internal.tasks.compile.incremental.processing.IncrementalAnnotationProcessorType.AGGREGATING;

/**
 * The strategy used for aggregating annotation processors.
 * @see AggregatingProcessor
 */
class AggregatingProcessingStrategy extends IncrementalProcessingStrategy {

    AggregatingProcessingStrategy(AnnotationProcessorResult result) {
        super(result);

 *
 * This service is called by compiler through Compiler API.
 *
 * We don't backup classes/resources generated by annotation processors, since any overwriting of existing generated types
 * that were not deleted by Gradle before annotation processing, would anyway result in full-recompilation, due to annotation processors limitations.

        0    | 4
        0    | 10
        1    | 1
        1    | 4
        1    | 10
        5    | 1
        5    | 4
        5    | 10
    }

    def "does not submit more work processors than #threads threads"() {
        given:
        setupQueue(threads)
        lease.leaseFinish() // Release worker lease to allow operation to run, when there is max 1 worker thread

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

/**
 * An annotation processor that did not opt into incremental processing.
 * Any use of such a processor will result in full recompilation.
 * As opposed to the other processor implementations, this one will not

    RunPreviousFailedFirstTestClassProcessor processor

    def 'previous failed test classes should be passed to delegate first'() {
        given:
        processor = new RunPreviousFailedFirstTestClassProcessor(['Class3'] as Set, delegate)

        when:
        processor.startProcessing(testResultProcessor)
        ['Class1', 'Class2', 'Class3'].each { processor.processTestClass(new DefaultTestClassRunInfo(it)) }

import java.io.Serializable;

/**
 * Information about an annotation processor, based on its static metadata
 * in <code>META-INF/services/javax.annotation.processing.Processor</code> and
 * <code>META-INF/gradle/incremental.annotation.processors</code>
 */
public class AnnotationProcessorDeclaration implements Serializable {
    private final String className;

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.compile.incremental.processing;

import java.util.Locale;

/**
 * The different kinds of annotation processors that the incremental compiler knows how to handle.
 * See the user guide chapter on incremental annotation processing for more information.
 */
public enum IncrementalAnnotationProcessorType {
    ISOLATING,

        }

        if (processor == null) {
            processor = factory.create();
            processor.startProcessing(resultProcessor);
        }
        processor.processTestClass(testClass);
        testCount++;
        if (testCount == restartEvery) {
            endBatch();
        }
    }

    @Override
    public void stop() {
        if (processor != null) {
            endBatch();
        }

import javax.lang.model.element.TypeElement;
import java.util.Set;

/**
 * A simple base class for annotation processors that decorate another one.
 */
abstract class DelegatingProcessor implements Processor {
    private final Processor delegate;

    DelegatingProcessor(Processor delegate) {
        this.delegate = delegate;
    }

    @Override
    public Set<String> getSupportedOptions() {

Below is the configuration:

```yaml
receivers:
  otlp:
    protocols:
      grpc:
      http:
processors:
  batch:
exporters:
  logging:
    loglevel: debug
service:
  pipelines:
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [logging]
```