*/

package org.gradle.workers.internal;

import java.io.File;

/**
 * Represents the directories a worker needs to understand in order to execute.
 *
 * TODO: This, and its subclasses, should probably be renamed to indicate that it is only about directories (for now)
 */
public interface WorkerRequirement {
    /**
     * Returns the directory in which to execute new workers.
     *

 */

package org.gradle.internal.classloader;

import java.io.Serializable;

/**
 * An immutable description of a ClassLoader hierarchy that can be used to recreate the hierarchy in a different process.
 *
 * Subclasses should implement equals() and hashCode(), so that the spec can be used as a hashmap key.
 */
public abstract class ClassLoaderSpec implements Serializable {

      /*
       * The future no longer needs to interrupt this task, so it no longer needs a reference to it.
       *
       * TODO(cpovirk): It might be nice for our InterruptibleTask subclasses to null out their
       *  `callable` fields automatically. That would make it less important for us to null out the
       * reference to `task` here (though it's still nice to do so in case our reference to the

      /*
       * The future no longer needs to interrupt this task, so it no longer needs a reference to it.
       *
       * TODO(cpovirk): It might be nice for our InterruptibleTask subclasses to null out their
       *  `callable` fields automatically. That would make it less important for us to null out the
       * reference to `task` here (though it's still nice to do so in case our reference to the

    /**
     * For all classes with Java source that we will be recompiled due to some change, we need to recompile all subclasses.
     * This is because Groovy might try to load some subclass when analysing Groovy classes before Java compilation, but if parent class was stale,
     * it has been deleted, so class loading of a subclass will fail.
     *
     * Fix for issue <a href="https://github.com/gradle/gradle/issues/22531">#22531</a>.
     */

    }

    def "can create instance of final class when a subclass is not required"() {
        expect:
        create(FinalBean) != null
    }

    def "can create instance of private class when a subclass is not required"() {
        expect:
        create(PrivateBean) != null
    }

    def "generates subclass that is not decorated when class is abstract"() {
        expect:

 *
 * <p>Subclasses are guaranteed that the life cycle methods ({@link #runOneIteration}, {@link
 * #startUp} and {@link #shutDown}) will never run concurrently. Notably, if any execution of {@link
 * #runOneIteration} takes longer than its schedule defines, then subsequent executions may start
 * late. Also, all life cycle methods are executed with a lock held, so subclasses can safely modify

/**
 * A package-local class holding common representation and mechanics for classes supporting dynamic
 * striping on 64bit values. The class extends Number so that concrete subclasses must publicly do
 * so.
 */
@GwtIncompatible
@ElementTypesAreNonnullByDefault
@SuppressWarnings({"SunApi", "removal"}) // b/345822163
abstract class Striped64 extends Number {
  /*

 *
 * <p>Consumer compatibility: This interface is used by all consumer versions from 4.4.</p>
 * <p>Provider compatibility: This interface is implemented by all provider versions from 4.4.</p>
 *
 * <p>Subclasses may also implement {@link InternalActionAwareBuildController} and {@link InternalStreamedValueRelay}.</p>
 *
 * @since 4.4
 */
public interface InternalBuildControllerVersion2 {
    /**

            return doIntersect(leftType.cast(right), rightType.cast(left), factory);
        }
    }

    /**
     * Intersects the given exclude specs.
     *
     * This method is meant to be implemented by subclasses realizing a specific intersection of types.
     *
     * @param left an exclude spec
     * @param right another exclude spec
     * @param factory the factory that can be used to create a new exclude spec
     *