import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class DefaultProjectSchemaProviderTest {

    @Test
    fun `chooses first public interface in type hierarchy`() {

        val androidExtensionsSchema = DefaultExtensionsSchema.create(
            listOf(
                extensionSchema(
                    "kotlinOptions",
                    typeOf<KotlinJvmOptionsImpl>()

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

package org.gradle.initialization;

import java.util.Set;

/**
 * Fired once the hierarchy of projects is finalized for a build in the tree, and before any build operations
 * that reference those projects are executed.
 *
 * @since 8.0
 */
public interface ProjectsIdentifiedProgressDetails {
    /**

import org.gradle.api.Incubating;

import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;

/**
 * Represents a group of problems.
 * <p>
 * Groups are organized in hierarchy where the parent group should represent the more broad problem group.
 * <p>
 * Two problem groups  are considered equal if their {@link #getName()} and their parents' are equal.
 *
 * @since 8.8
 * @see ProblemId
 */

            missing(dir.absolutePath + "/missing.txt")
        ]))
        then:
        rootsOf(watched) == []
        1 * watchable.stream() >> Stream.of(dir)
    }

    def "watches only outermost hierarchy"() {
        def watchable = Mock(WatchableHierarchies)
        def parent = new File("parent").absoluteFile
        def child = new File(parent, "child").absoluteFile

    @Override
    void visitSpecAnnotation(AllFeaturesShouldBeAnnotated runFor, SpecInfo spec) {
        while (spec.subSpec != null) {
            // Find the bottom spec in the hierarchy
            spec = spec.subSpec
        }

        if (!spec.getReflection().isAnnotationPresent(RunFor) &&
            !spec.getReflection().isAnnotationPresent(Ignore) &&

            buildTask.dependsOn(buildTaskDependencies);
        }
    }

    @Override
    public TaskDependency getBuildDependencies() {
        // TODO maybe inject the task dependency factory into this type hierarchy, too
        final TaskDependencyFactory taskDependencyFactory = DefaultTaskDependencyFactory.withNoAssociatedProject();
        return taskDependencyFactory.visitingDependencies(context -> {
            if (buildTask == null) {

        waitForBuild()
        stopGradle()
        afterBuild()

        then: "test build operations are emitted in expected hierarchy"
        def testRootOperations = operations.all(ExecuteTestBuildOperationType) {
            it.details.testDescriptor.name.startsWith("Gradle Test Run")
        }
        testRootOperations.size() == 2

    }

    public static final String ANALYSIS_OUTPUT_DIR = "analysis";
    public static final String MERGE_OUTPUT_DIR = "merge";
    public static final String TYPE_HIERARCHY_ANALYSIS_FILE_NAME = "instrumentation-hierarchy.bin";
    public static final String DEPENDENCY_ANALYSIS_FILE_NAME = "instrumentation-dependencies.bin";

    public static InstrumentationInputType getInputType(File input) {
        if (isInstrumentationMarkerFile(input)) {

import org.gradle.internal.HasInternalProtocol;

import java.io.File;
import java.util.Set;

/**
 * <p>A {@code ProjectDependency} is a {@link Dependency} on another project in the current project hierarchy.</p>
 */
@HasInternalProtocol
@SuppressWarnings("deprecation") // Because of SelfResolvingDependency
public interface ProjectDependency extends ModuleDependency, SelfResolvingDependency {
    /**

import org.gradle.api.tasks.util.PatternFilterable;
import org.gradle.internal.HasInternalProtocol;

import java.io.File;
import java.util.Set;

/**
 * <p>A {@code FileTree} represents a hierarchy of files. It extends {@link FileCollection} to add hierarchy query and
 * manipulation methods. You typically use a {@code FileTree} to represent files to copy or the contents of an
 * archive.</p>
 *