* 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.DefaultTestClassRunInfo
import org.gradle.api.internal.tasks.testing.TestClassProcessor
import org.gradle.api.internal.tasks.testing.TestResultProcessor

        return merged;
    }

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

import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.JavaFileManager;
import java.util.Set;

/**
 * The strategy used for dynamic processors.
 *
 * @see DynamicProcessor
 */
public class DynamicProcessingStrategy extends IncrementalProcessingStrategy {

    private IncrementalProcessingStrategy delegate;

 * 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;

     *
     * <ul>
     *     <li>A thread running a task</li>
     *     <li>A test process</li>
     *     <li>A language compiler in a forked process</li>
     * </ul>
     *
     * Defaults to the number of processors available to the Java virtual machine.
     *
     * @return maximum number of concurrent workers, always &gt;= 1.
     * @see java.lang.Runtime#availableProcessors()
     */
    int getMaxWorkerCount();

    /**

import javax.lang.model.util.Types;
import java.util.Locale;
import java.util.Map;

/**
 * A decorator for the {@link ProcessingEnvironment} provided by the Java compiler,
 * which allows us to intercept calls from annotation processors in order to validate
 * their behavior.
 */
class IncrementalProcessingEnvironment implements ProcessingEnvironment {
    private final ProcessingEnvironment delegate;
    private final IncrementalFiler filer;

import java.util.Set;

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

/**
 * The strategy used for non-incremental annotation processors.
 * @see NonIncrementalProcessor
 */
public class NonIncrementalProcessingStrategy extends IncrementalProcessingStrategy {
    private final String name;

Configuration annotationProcessor
--------------------------------------------------
Annotation processors and their dependencies for source set 'main'.

Attributes
    - org.gradle.category            = library
    - org.gradle.dependency.bundling = external
    - org.gradle.jvm.environment     = standard-jvm

import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
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;
    }

 * 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;