@ToBeFixedForConfigurationCache
    def "returns meaningful errors from xcode when component product is unbuildable due to architecture"() {
        useXcodebuildTool()

        given:
        makeSingleProject()
        buildFile << configureTargetMachines("machines.${currentHostOperatingSystemFamilyDsl}.architecture('foo')")
        buildFile << configureToolChainSupport('foo')

        componentUnderTest.writeToProject(testDirectory)

        createDirs("a", "b", "c")
        settingsFile << """
            include 'a', 'b', 'c'
        """
        taskTypeWithOutputFileProperty()
        buildFile << """
            import ${Inject.name}
            import ${ToolingModelBuilderRegistry.name}
            import ${ToolingModelBuilder.name}

            abstract class SomePlugin implements Plugin<Project> {

        addBuilderRegisteringPluginImplementation("plugins", "MyModelBuilder")

        settingsFile << """
            includeBuild("plugins")
            rootProject.name = 'root'
        """
        buildFile << """
            plugins {
                id("my.plugin")
            }
        """

        when:
        def model = toolingApi.withConnection() { connection -> connection.getModel(BaseModel) }

import org.gradle.tooling.events.ProgressListener

import java.util.regex.Pattern

@TargetGradleVersion(">=4.8")
class PhasedBuildActionCrossVersionSpec extends ToolingApiSpecification {
    def setup() {
        buildFile << """
            import org.gradle.tooling.provider.model.ParameterizedToolingModelBuilder
            import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
            import javax.inject.Inject

import org.junit.Rule

class ParallelActionExecutionCrossVersionSpec extends ToolingApiSpecification {
    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        buildFile << """
            import javax.inject.Inject
            import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
            import org.gradle.tooling.provider.model.ToolingModelBuilder

@ToolingApiVersion(">=8.1")
@Requires(IntegTestPreconditions.NotEmbeddedExecutor)
class ToolchainsParallelActionExecutionCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        buildFile << """
            import javax.inject.Inject
            import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
            import org.gradle.tooling.provider.model.ToolingModelBuilder

    def "deprecation is reported when tooling model builder resolves configuration from a project other than its target"() {
        settingsFile << """
            include("a")
        """
        buildFile << """
            import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
            import org.gradle.tooling.provider.model.ToolingModelBuilder
            import org.gradle.api.Project

    def setup() {
        file('settings.gradle') << '''
include 'a'
include 'b'
include 'b:c'
rootProject.name = 'test'
'''
        file('b').mkdirs()

        buildFile << """
allprojects {
    description = "project \$name"
    apply plugin: CustomPlugin
    task buildStuff
}

import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry

            }
        """
    }

    @TargetGradleVersion("=8.6")
    def "Can use problems service in model builder and get problem"() {
        given:
        Assume.assumeTrue(jdk != null)
        buildFile getBuildScriptSampleContent(false, false, targetVersion)
        def listener = new ProblemProgressListener()

        when:
        withConnection {
            it.model(CustomModel)

class ComponentMetadataRulesErrorHandlingIntegrationTest extends AbstractHttpDependencyResolutionTest {
    final resolve = new ResolveFailureTestFixture(buildFile)

    def setup() {
        ivyRepo.module('org.test', 'projectA', '1.0').publish()
        buildFile << """
            repositories {
                ivy {
                    url "$ivyRepo.uri"
                }
            }