}

    def isolatableFactory = new TestIsolatableFactory()
    def classLoaderHierarchyHasher = Mock(ClassLoaderHierarchyHasher)
    def calculatedValueContainerFactory = TestUtil.calculatedValueContainerFactory()
    def attributesFactory = AttributeTestUtil.attributesFactory()
    def registryFactory = new DefaultTransformRegistrationFactory(
        new TestBuildOperationRunner(),

import org.gradle.internal.hash.ChecksumService;
import org.gradle.internal.hash.DefaultChecksumService;
import org.gradle.internal.jvm.JavaModuleDetector;
import org.gradle.internal.model.CalculatedValueContainerFactory;
import org.gradle.internal.model.StateTransitionControllerFactory;
import org.gradle.internal.nativeintegration.filesystem.FileSystem;
import org.gradle.internal.operations.BuildOperationRunner;

    private final DefaultDomainObjectSet<Dependency> ownDependencies;
    private final DefaultDomainObjectSet<DependencyConstraint> ownDependencyConstraints;
    private final CalculatedValueContainerFactory calculatedValueContainerFactory;
    private final ProjectStateRegistry projectStateRegistry;
    private CompositeDomainObjectSet<Dependency> inheritedDependencies;

        new LocalComponentGraphResolveStateFactory(
            Stub(AttributeDesugaring),
            Stub(ComponentIdGenerator),
            configurationMetadataBuilder,
            TestUtil.calculatedValueContainerFactory()
        )
    )

    def builder = builderFactory.create(configurationsProvider)

    def "caches root component resolve state and metadata"() {

    }

    def create() {
        return converter.create(configuration, configurationsProvider, componentId, cache, RootScriptDomainObjectContext.INSTANCE, TestUtil.calculatedValueContainerFactory())
    }

        FileLookup fileLookup,
        PropertyWalker parameterPropertyWalker,
        InstantiationScheme actionInstantiationScheme,
        DomainObjectContext owner,
        CalculatedValueContainerFactory calculatedValueContainerFactory,
        ServiceLookup internalServices
    ) {
        this.implementationClass = implementationClass;
        this.fromAttributes = fromAttributes;
        this.toAttributes = toAttributes;

        managedFactoryRegistry = mock(),
        parameterScheme = mock(),
        actionScheme = mock(),
        attributesFactory = mock(),
        valueSourceProviderFactory = mock(),
        calculatedValueContainerFactory = mock(),
        patternSetFactory = mock(),
        fileOperations = mock(),
        fileFactory = mock(),
        includedTaskGraph = mock(),
        buildStateRegistry = mock(),

            TestUtil.calculatedValueContainerFactory().create(Describables.of(name, "dependencies"),
                new DefaultLocalConfigurationMetadata.ConfigurationDependencyMetadata(dependencies, [] as Set, [])
            )

        CalculatedValue<ImmutableList<LocalComponentArtifactMetadata>> artifactMetadata =
            TestUtil.calculatedValueContainerFactory().create(Describables.of(name, "artifacts"),

    def selector = Mock(ArtifactVariantSelector)
    def artifactTypeRegistry = Mock(ArtifactTypeRegistry)
    def set = new DefaultLocalFileDependencyBackedArtifactSet(dep, filter, selector, artifactTypeRegistry, TestUtil.calculatedValueContainerFactory(), ImmutableAttributes.EMPTY, false)

    def "has build dependencies"() {
        def fileBuildDependencies = Stub(TaskDependency)
        def files = Stub(FileCollectionInternal)

    def domainObjectCollectioncallbackActionDecorator = Mock(CollectionCallbackActionDecorator)
    def userCodeApplicationContext = Mock(UserCodeApplicationContext)
    def calculatedValueContainerFactory = Mock(CalculatedValueContainerFactory)

    def setup() {