import org.gradle.util.AttributeTestUtil
import spock.lang.Shared
import spock.lang.Specification

import static org.gradle.internal.component.external.model.DefaultModuleComponentSelector.newSelector

class VariantFilesMetadataRulesTest extends Specification {
    @Shared versionIdentifier = new DefaultModuleVersionIdentifier("org.test", "producer", "1.0")

		}
		a.networkUpdateTrigger.MarkDependant(ctx) // Mark we depend on out of band a.Network
		return &model.ServiceInfo{
			Service:       a.constructService(s, waypoint),
			PortNames:     portNames,
			LabelSelector: model.NewSelector(s.Spec.Selector),
			Source:        kind.Service,
			Waypoint:      waypointKey,
		}
	}, krt.WithName("ServicesInfo"))

        }
        String version = split[2].trim();
        if (!GUtil.isTrue(version)) {
            throw new UnsupportedNotationException(notation);
        }
        return DefaultModuleComponentSelector.newSelector(moduleIdentifierFactory.module(group, name), DefaultImmutableVersionConstraint.of(version));
    }

    @Override
    public void describe(DiagnosticsVisitor visitor) {

    }

    @Override
    ResolvedVersionConstraint getVersionConstraint() {
        return null
    }


    @Override
    ComponentSelector getSelector() {
        return DefaultProjectComponentSelector.newSelector(projectId)
    }

    @Override
    ComponentIdResolveResult resolve(VersionSelector allRejects) {
        def result = new DefaultBuildableComponentIdResolveResult()

        boolean changing = externalModuleDependency.isChanging();
        boolean transitive = externalModuleDependency.isTransitive();

        ModuleComponentSelector selector = DefaultModuleComponentSelector.newSelector(
            DefaultModuleIdentifier.newId(nullToEmpty(dependency.getGroup()), nullToEmpty(dependency.getName())),
            ((VersionConstraintInternal) externalModuleDependency.getVersionConstraint()).asImmutable(),

    }

    def "does not match for dependencies other than requested ModuleComponentSelector"() {
        expect:
        !new DependencyResultSpec(notation).isSatisfiedBy(newDependency(TestComponentIdentifiers.newSelector(":myPath"), "org.foo", "foo-core", "1.22"))

        where:
        notation << ['1.+']
    }

            if (!moduleAttributes.isEmpty()) {
                ImmutableAttributes attributes = ((AttributeContainerInternal) moduleAttributes).asImmutable();
                return DefaultModuleComponentSelector.newSelector(module.getModuleIdentifier(), module.getVersionConstraint(), desugar(attributes), module.getRequestedCapabilities());
            }
        }
        if (selector instanceof DefaultProjectComponentSelector) {

        configureAction.execute(attributes);
        ModuleComponentSelector target = DefaultModuleComponentSelector.newSelector(selector.getModuleIdentifier(), selector.getVersionConstraint(), attributes.asImmutable(), selector.getRequestedCapabilities());
        ModuleDependencyMetadata metadata = (ModuleDependencyMetadata) getMetadata().withTarget(target);

    }

    def "resolves project dependency"() {
        setup:
        def selector = TestComponentIdentifiers.newSelector(":project")
        def componentState = Mock(LocalComponentGraphResolveState)
        def result = Mock(BuildableComponentIdResolveResult)
        def dependencyMetaData = Stub(DependencyMetadata) {

        return new DependencyResult() {
            @Override
            public ComponentSelector getRequested() {
                return DefaultModuleComponentSelector.newSelector(versionIdentifier.getModule(), versionIdentifier.getVersion());
            }

            @Override
            public ResolvedComponentResult getFrom() {
                return null;
            }