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

package org.gradle.api.internal.tasks.testing.processors

import org.gradle.api.internal.tasks.testing.TestClassProcessor
import org.gradle.api.internal.tasks.testing.TestClassRunInfo
import org.gradle.api.internal.tasks.testing.TestResultProcessor

        file("build/classes/java/main/AHelperResource.txt").delete()
        run "compileJava"

        then:
        outputs.recompiledFiles('A', "AHelper", "AHelperResource.txt", "Unrelated")
    }

    def "processors must provide an originating element for each source element"() {
        given:

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]
```

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

package org.gradle.api.internal.tasks.testing.processors

import org.gradle.api.internal.tasks.testing.TestClassProcessor
import org.gradle.api.internal.tasks.testing.TestClassRunInfo
import org.gradle.api.internal.tasks.testing.TestResultProcessor

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

package org.gradle.api.internal.tasks.testing.processors;

import org.gradle.api.internal.tasks.testing.TestClassProcessor;
import org.gradle.api.internal.tasks.testing.TestClassRunInfo;
import org.gradle.api.internal.tasks.testing.TestResultProcessor;

        List<InterpolationPostProcessor> processors = new ArrayList<>(2);
        if (projectDir != null) {
            processors.add(new PathTranslatingPostProcessor(
                    getProjectPrefixes(request), TRANSLATED_PATH_EXPRESSIONS, projectDir, pathTranslator));
        }
        processors.add(new UrlNormalizingPostProcessor(urlNormalizer));
        return processors;
    }

 * Any use of such a processor will result in full recompilation.
 * As opposed to the other processor implementations, this one will not
 * decorate the processing environment, because there are some processors
 * that cast it to its implementation type, e.g. JavacProcessingEnvironment.
 */
public class NonIncrementalProcessor extends DelegatingProcessor {

    private final NonIncrementalProcessingStrategy strategy;

    public static FilteringClassLoader getFilteredClassLoader(ClassLoader parent) {
        return new FilteringClassLoader(parent, getExtraAllowedPackages());
    }

    /**
     * Many popular annotation processors like lombok need access to compiler internals
     * to do their magic, e.g. to inspect or even change method bodies. This is not valid
     * according to the annotation processing spec, but forbidding it would upset a lot of

/**
 * 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;
    private final IncrementalAnnotationProcessorType type;

        return merged;
    }

    private AnnotationProcessingData getAnnotationProcessingData(JavaCompileSpec spec, WorkResult result) {
        Set<AnnotationProcessorDeclaration> processors = spec.getEffectiveAnnotationProcessors();
        if (processors.isEmpty()) {
            return new AnnotationProcessingData();
        }
        AnnotationProcessingData previousAnnotationProcessingData = null;