t2 == failure

        when:
        controller.configureProjects()

        then:
        def t3 = thrown RuntimeException
        t3 == failure
    }

    void testConfigureBuild() {
        def controller = controller()

        when:
        controller.configureProjects()

        then:
        1 * buildModelController.configuredModel >> gradleMock

        return state.notInState(State.Finished, () -> action.apply(modelController.getLoadedSettings()));
    }

    @Override
    public void configureProjects() {
        state.notInState(State.Finished, modelController::getConfiguredModel);
    }

    @Override
    public <T> T withProjectsConfigured(Function<? super GradleInternal, T> action) {

        }

        @Override
        <T> T withSettings(Function<? super SettingsInternal, T> action) {
            throw new UnsupportedOperationException()
        }

        @Override
        void configureProjects() {
            throw new UnsupportedOperationException()
        }

        @Override
        <T> T withProjectsConfigured(Function<? super GradleInternal, T> action) {

        checkConfigureProject('subprojects', listWithAllChildProjects)
    }

    def allprojects() {
        expect:
        checkConfigureProject('allprojects', listWithAllProjects)
    }

    def configureProjects() {
        expect:
        checkConfigureProject('configure', [project, child1] as Set)
    }

    private void checkConfigureProject(String configureMethod, Set projectsToCheck) {

        withUniqueScript("$className().foo()")
        configureProject().assertBuildScriptCompiled().assertOutputContains("foo")

        givenJavaClassInBuildSrcContains("""public void foo() { System.out.println("bar"); }""")
        configureProject().assertBuildScriptBodyRecompiled().assertOutputContains("bar")
    }

    @Test

    }

    def "can publish ivy publication metadata to remote repository"() {
        def username = "someuser"
        def password = "somepassword"
        def projectConfig = configureProject(username, password, "ivyRepo", false)
        def configurationCache = newConfigurationCacheFixture()
        def metadataFile = file('build/publications/ivy/module.json')

        expect:

        """
    }

    def "can publish maven publication metadata to remote repository"() {
        def username = "someuser"
        def password = "somepassword"
        def projectConfig = configureProject(username, password, "mavenRepo", false)
        def configurationCache = newConfigurationCacheFixture()
        def metadataFile = file('build/publications/maven/module.json')

        expect:

    }

    private void assertNothingConfigured() {
        def configuredProjects = buildOperations.all(ConfigureProjectBuildOperationType)
        // A synthetic "project configured" operation is fired for each root project for build scans
        assert configuredProjects.every { it.details.projectPath == ':' }

        def scripts = buildOperations.all(ApplyScriptPluginBuildOperationType)

        configurationCacheBuildOperations.assertNoConfigurationCache()
    }

    private void assertProjectsConfigured(HasIntermediateDetails details) {
        def configuredProjects = buildOperations.all(ConfigureProjectBuildOperationType)
        assert configuredProjects.collect { fullPath(it) }.toSet() == details.projects

        // Scripts - one or more for settings, and one for each project build script

    }

    @Override
    public List<VersionCatalogBuilder> getDependenciesModelBuilders() {
        return ImmutableList.copyOf(versionCatalogs);
    }

    @Override
    public void configureProject(ProjectInternal project) {
        if (!getConfiguredRepositoriesMode().useProjectRepositories()) {
            project.getRepositories().whenObjectAdded(this::repoMutationDisallowedOnProject);
        }