queue.removeFirst();
                        continue;
                    }
                }
                if (goal.state == ModelGoal.State.VisitingDependencies) {
                    // All dependencies visited
                    goal.apply();
                    goal.state = ModelGoal.State.Achieved;
                    queue.removeFirst();
                    continue;
                }

    }

    public static List<String> toStringList(Iterable<?> iterable) {
        return collect(iterable, new LinkedList<String>(), InternalTransformers.asString());
    }

    /**
     * Recursively unpacks all the given things into a flat list.
     *
     * Nulls are not removed, they are left intact.
     *
     * @param things The things to flatten
     * @return A flattened list of the given things
     */

                if (visitAll(sourceTree)) {
                    fileTrees.add(sourceTree.getMirror());
                }
            }
        });
        return fileTrees;
    }

    /**
     * Visits all the files of the given tree.
     */
    protected static boolean visitAll(FileSystemMirroringFileTree tree) {
        final MutableBoolean hasContent = new MutableBoolean();
        tree.visit(new FileVisitor() {

        init.useDefaults.convention(false)
        init.comments.convention(true)
        init.allowFileOverwrite.convention(false)
    }

    def "creates project with all defaults"() {
        given:
        projectLayoutRegistry.buildConverter >> buildConverter
        buildConverter.canApplyToCurrentDirectory() >> false

import java.util.Optional;
import java.util.Set;

/**
 * Provides a central location for handling failures encountered during
 * each stage of the variant selection process during dependency resolution.
 *
 * All variant selection failures encountered during selection by the {@link GraphVariantSelector} or
 * {@link AttributeMatchingArtifactVariantSelector}
 * should be routed through this class.
 *

    }

    // withType when used with a class that is not a super-class of the container does not work with registered elements
    @NotYetImplemented
    def "can find all configurations even when they're registered"() {
        when:
        configurationContainer.register("foo")
        configurationContainer.create("bar")
        then:

        def action = Mock(Action)
        def task = task("task")

        taskFactory.create(_ as TaskIdentity) >> task
        action.execute(task) >> { throw failure }

        when:
        container.all(action)
        container.create("task", action)

        then:
        def e = thrown(GradleException)
        e.message == "Could not create task ':project:task'."
        e.cause == failure
    }

        storeOps.size() == 1
        storeOps.first().failure.contains("response status 401: Unauthorized")
    }

    private List<BuildOperationRecord> compileJavaStoreOperations() {
        buildOperations.all(BuildCacheRemoteStoreBuildOperationType) {
            buildOperations.parentsOf(it).any {
                it.hasDetailsOfType(ExecuteTaskBuildOperationType.Details) && it.details.taskPath == ":compileJava"
            }

    }

    def 'catastrophic failure of every test task prevents creation of aggregated report'() {
        given:
        // prevent all test VMs from starting
        buildFile << '''
                subprojects {
                    plugins.withId('java') {
                        testing {
                            suites {

        blockingServer.expectConcurrent(":b:aPing", ":b:bPing")
        run ":a:aSerialPing", ":b:aPing", ":b:bPing"

        // when configuration is loaded from configuration cache, all tasks are executed in parallel
        if (GradleContextualExecuter.configCache) {
            blockingServer.expectConcurrent(":a:aSerialPing", ":b:aPing", ":b:bPing")
            run ":a:aSerialPing", ":b:aPing", ":b:bPing"