resolutions
        );
    }

    private boolean settingsRepositoriesIgnored() {
        if (!(domainObjectContext instanceof ProjectInternal)) {
            return false;
        }

        ProjectInternal project = (ProjectInternal) domainObjectContext;

        boolean hasSettingsRepos;
        try {

import java.util.Optional;

class LocalPluginResolution implements PluginResolution {
    private final PluginId pluginId;
    private final ProjectInternal producingProject;

    private LocalPluginResolution(PluginId pluginId, ProjectInternal producingProject) {
        this.pluginId = pluginId;
        this.producingProject = producingProject;
    }

    @Override
    public PluginId getPluginId() {

import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.model.internal.core.NamedEntityInstantiator;

public class TaskInstantiator implements NamedEntityInstantiator<Task> {
    private static final Object[] NO_PARAMS = new Object[0];

    private final TaskIdentityFactory taskIdentityFactory;
    private final ITaskFactory taskFactory;
    private final ProjectInternal project;

        !filter.isSatisfiedBy(excluded)
        filter.isSatisfiedBy(notExcluded)
    }

    ProjectState project(String path, ProjectInternal model) {
        def state = Stub(ProjectState)
        state.mutableModel >> model
        return state
    }

    def task(ProjectInternal project, String name) {
        def task = Stub(TaskInternal) {
            getProject() >> project
            getName() >> name

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

package org.gradle.tooling.provider.model.internal

import org.gradle.api.internal.project.ProjectInternal
import org.gradle.api.internal.project.ProjectState
import org.gradle.api.internal.project.ProjectStateRegistry
import org.gradle.internal.Describables
import org.gradle.internal.Factory

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.provider

import org.gradle.api.internal.project.ProjectInternal


interface KotlinScriptBasePluginsApplicator {

    fun apply(project: ProjectInternal)

import org.gradle.api.internal.plugins.DefaultArtifactPublicationSet;
import org.gradle.api.internal.plugins.NaggingBasePluginConvention;
import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.plugins.internal.DefaultBasePluginExtension;
import org.gradle.api.tasks.bundling.AbstractArchiveTask;
import org.gradle.internal.deprecation.DeprecationLogger;

     */
    void setDefaultProject(ProjectInternal defaultProject);

    /**
     * Called by the BuildLoader after the root project is determined.  Until the BuildLoader
     * is executed, {@link #getRootProject()} will throw {@link IllegalStateException}.
     *
     * @param rootProject The root project for this build.
     */
    void setRootProject(ProjectInternal rootProject);

    /**

import org.gradle.api.artifacts.component.ProjectComponentIdentifier;
import org.gradle.api.internal.project.ProjectInternal;

public class ProjectBackedModule implements Module {

    private final ProjectInternal project;

    public ProjectBackedModule(ProjectInternal project) {
        this.project = project;
    }

    @Override
    public String getGroup() {

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

package org.gradle.configuration.project
import org.gradle.api.internal.project.ProjectInternal
import org.gradle.internal.service.DefaultServiceLocator
import spock.lang.Specification

class PluginsProjectConfigureActionsTest extends Specification {
    final def pluginsClassLoader = Mock(ClassLoader)