import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.FORCED
import static org.gradle.internal.component.external.model.DefaultModuleComponentSelector.newSelector

class DependencyInsightReporterSpec extends Specification {
    def versionParser = new VersionParser()
    def versionComparator = new DefaultVersionComparator()

        for (ComponentVariant.Dependency dependency : variant.getDependencies()) {
            ModuleComponentSelector selector = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId(dependency.getGroup(), dependency.getModule()), dependency.getVersionConstraint(), dependency.getAttributes(), dependency.getRequestedCapabilities());

import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

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

public class ModuleComponentSelectorSerializer implements Serializer<ModuleComponentSelector> {
    private final AttributeContainerSerializer attributeContainerSerializer;

import org.gradle.api.provider.ProviderConvertible
import org.gradle.internal.typeconversion.UnsupportedNotationException
import spock.lang.Specification

import static org.gradle.api.internal.artifacts.DefaultModuleVersionSelector.newSelector
import static org.gradle.api.internal.artifacts.dsl.ModuleVersionSelectorParsers.multiParser
import static org.gradle.api.internal.artifacts.dsl.ModuleVersionSelectorParsers.parser

                    if (testClass != null) {
                        newSelector = DiscoverySelectors.selectClass(testClass);
                    }
                }
                result.add(newSelector);
            }
            return new ArrayList<T>(Cast.<Collection<T>>uncheckedCast(result));
        }
        return selectors;
    }

		pol := convertAuthorizationPolicy(meshCfg.GetRootNamespace(), i)
		if pol == nil {
			return nil
		}
		return &model.WorkloadAuthorization{
			Authorization: pol,
			LabelSelector: model.NewSelector(i.Spec.GetSelector().GetMatchLabels()),
		}
	}, krt.WithName("AuthzDerivedPolicies"))

        def selector = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId("x", requested), DefaultImmutableVersionConstraint.of("1"))
        def moduleVersionSelector = newSelector(DefaultModuleIdentifier.newId("x", requested), "1")
        failure = failure == null ? null : new ModuleVersionResolveException(moduleVersionSelector, failure)

    def "provides module details"() {
        when:
        def module = DefaultModuleIdentifier.newId("org.foo", "foo")
        def dep = new DefaultUnresolvedDependency(DefaultModuleVersionSelector.newSelector(module, '1.0'), new RuntimeException("boo!"))

        then:
        dep.selector.group == 'org.foo'
        dep.selector.name == 'foo'
        dep.selector.version == '1.0'
        dep.toString() == 'org.foo:foo:1.0'

            String dynamicConstraintVersion = dependency.getDynamicConstraintVersion();
            ModuleComponentSelector newSelector = DefaultModuleComponentSelector.newSelector(selector.getModuleIdentifier(), dynamicConstraintVersion);
            transformedDescriptors.put(dependency, dependency.withRequested(newSelector));
        }
        return this.withDependencies(transformedDescriptors);
    }

    @Override

			scaleExpected:      false,
		},
	}
	for i := range tests {
		test := tests[i]
		t.Logf("executing scenario %d", i)

		newSelector := map[string]string{"foo": "new"}
		oldSelector := map[string]string{"foo": "old"}
		newRS := rs("foo-new", test.newReplicas, newSelector, noTimestamp)
		newRS.Status.AvailableReplicas = int32(test.readyPodsFromNewRS)
		oldRS := rs("foo-old", test.oldReplicas, oldSelector, noTimestamp)