*/
class GroovyClass extends A implements CombinedInterface, JavaInterface {
    /**
     * A groovy property.
     */
    CombinedInterface groovyProp

    /**
     * A read-only groovy property.
     */
    final String readOnlyGroovyProp

    /**
     * An array property.
     */
    def String[] arrayProp

    private def ignoreMe1;
    public int ignoreMe2;
    protected int ignoreMe3;

 *
 * @param <R> The type of the values that all source providers must share.
 */
public class MergeProvider<R> extends AbstractMinimalProvider<List<R>> {

    private final List<Provider<R>> items;

    public MergeProvider(List<Provider<R>> items) {
        this.items = ImmutableList.copyOf(items);
    }

    @Override
    protected String toStringNoReentrance() {

import org.gradle.internal.file.TreeType;

public enum OutputFilePropertyType {
    FILE(TreeType.FILE),
    DIRECTORY(TreeType.DIRECTORY),
    FILES(TreeType.FILE),
    DIRECTORIES(TreeType.DIRECTORY);

    private final TreeType outputType;

    OutputFilePropertyType(TreeType outputType) {
        this.outputType = outputType;
    }

    public TreeType getOutputType() {
        return outputType;
    }

        prop.finalizeValue()

        when:
        prop.set(file)

        then:
        def e = thrown(IllegalStateException)
        e.message == 'The value for this property is final and cannot be changed any further.'
    }

    def "cannot set value using file provider when finalized"() {
        given:
        def file = tmpDir.file("thing")
        def prop = propertyWithNoValue()

 */

package gradlebuild.docs.dsl.docbook;

import gradlebuild.docs.dsl.docbook.model.ClassDoc;
import gradlebuild.docs.dsl.docbook.model.PropertyDoc;

public class ReferencedTypeBuilder {
    private final DslDocModel model;

    public ReferencedTypeBuilder(DslDocModel model) {
        this.model = model;
    }

    /**
     * Builds the docs for types referenced by properties and methods of the given class.
     */

public class NewIncubatingAPIRule extends AbstractGradleViolationRule {

    public NewIncubatingAPIRule(Map<String, Object> params) {
        super(params);
    }

    @Override
    public Violation maybeViolation(final JApiCompatibility member) {
        if (member instanceof JApiMethod || member instanceof JApiField || member instanceof JApiClass) {
            if (!isIncubating((JApiHasAnnotations) member)) {
                return null;

import me.champeau.gradle.japicmp.report.ViolationCheckContext;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class AcceptedRegressionsRuleSetup implements SetupRule {

    private final Set<ApiChange> acceptedApiChanges;

    public AcceptedRegressionsRuleSetup(Map<String, String> acceptedApiChanges) {
        this.acceptedApiChanges = AcceptedApiChanges.fromAcceptedChangesMap(acceptedApiChanges).keySet();
    }

import org.gradle.internal.file.Stat;

import java.io.File;
import java.util.concurrent.atomic.AtomicBoolean;

public class DefaultFileVisitDetails extends DefaultFileTreeElement implements FileVisitDetails {
    private final AtomicBoolean stop;

    public DefaultFileVisitDetails(File file, RelativePath relativePath, AtomicBoolean stop, Chmod chmod, Stat stat) {
        super(file, relativePath, chmod, stat);
        this.stop = stop;
    }

import org.gradle.tooling.model.gradle.BasicGradleProject;
import org.gradle.tooling.model.gradle.GradleBuild;

public class FetchCustomModelForTargetProject implements BuildAction<SomeToolingModel> {

    private final String targetProject;

    public FetchCustomModelForTargetProject(String targetProject) {
        this.targetProject = targetProject;
    }

    @Override

import org.gradle.api.internal.model.NamedObjectInstantiator;
import org.gradle.internal.Cast;

import javax.annotation.Nullable;

public class CoercingStringValueSnapshot extends StringValueSnapshot {
    private final NamedObjectInstantiator instantiator;

    public CoercingStringValueSnapshot(String value, NamedObjectInstantiator instantiator) {
        super(value);
        this.instantiator = instantiator;
    }

    @Nullable