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

// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"runtime"
)

const N = 100000

func main() {
	// Allocate more Ps than processors.  This raises
	// the chance that we get interrupted by the OS
	// in exactly the right (wrong!) place.
	p := runtime.NumCPU()
	runtime.GOMAXPROCS(2 * p)

	// Allocate some pointers.
	ptrs := make([]*int, p)

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;

import javax.tools.FileObject;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import java.io.IOException;

/**
 * A decorator for the {@link Filer} which ensures that incremental
 * annotation processors don't break the incremental processing contract.
 */
public class IncrementalFiler implements Filer {
    private final Filer delegate;
    private final IncrementalProcessingStrategy strategy;

import javax.tools.JavaFileManager;
import java.util.Set;

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

/**
 * The strategy for isolating annotation processors.
 *
 * @see IsolatingProcessor
 */
class IsolatingProcessingStrategy extends IncrementalProcessingStrategy {

    IsolatingProcessingStrategy(AnnotationProcessorResult result) {
        super(result);

        when:
        def result = convert("--max-workers", "$maxWorkerCount")

        then:
        result.maxWorkerCount == maxWorkerCount
    }

    def "converts empty arguments set max workers to number of processors"() {
        when:
        def result = convert()

        then:
        result.maxWorkerCount == Runtime.getRuntime().availableProcessors()
    }

    def "converts invalid max workers (#value)"() {

     * <p>
     * Annotation processing of Groovy code works by having annotation processors visit the Java stubs generated by the
     * Groovy compiler in order to support joint compilation of Groovy and Java source.
     * <p>
     * When set to {@code true}, stubs will be unconditionally generated for all Groovy sources, and Java annotations processors will be executed on those stubs.
     * <p>

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

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

import org.gradle.api.internal.tasks.testing.processors.CaptureTestOutputTestResultProcessor;
import org.gradle.api.internal.tasks.testing.redirector.JULRedirector;
import org.gradle.api.internal.tasks.testing.results.AttachParentTestResultProcessor;

 * 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.DefaultTestSuiteDescriptor;
import org.gradle.api.internal.tasks.testing.TestClassProcessor;
import org.gradle.api.internal.tasks.testing.TestCompleteEvent;