"regexp"
	"strings"

	"istio.io/istio/pkg/log"
)

// Selector is a Set of label filter expressions that get applied together to decide whether tests should be selected
// for execution or not.
type Selector struct {
	// The constraints are and'ed together.
	present Set
	absent  Set
}

var _ fmt.Stringer = Selector{}

// NewSelector returns a new selector based on the given presence/absence predicates.

        def variant2Artifacts = Stub(ResolvedArtifactSet)

        def selector = Stub(ArtifactVariantSelector)

        given:
        artifacts1.select(selector, _) >> variant1Artifacts
        artifacts2.select(selector, _) >> variant2Artifacts

        def results = new DefaultVisitedArtifactResults([artifacts1, artifacts2])
        def selected = results.select(selector, Mock(ArtifactSelectionSpec), false)

        expect:

        def same = factory.createResolvedDependency(selector('requested'), fromModule, selectedModule, variant, false)

        def differentRequested = factory.createResolvedDependency(selector('xxx'), fromModule, selectedModule, variant, false)

/**
 * Implementations of version selector are expected to be immutable and thread-safe.
 */
public interface VersionSelector {
    /**
     * Indicates if the given version selector is dynamic.
     */
    boolean isDynamic();

    /**
     * Indicates if module metadata is required to determine if the
     * selector matches a candidate version.
     */
    boolean requiresMetadata();

			WantException:  true,
		},
		{ // case 7
			Args:           strings.Split("jaeger --browser=false", " "),
			ExpectedOutput: "Error: no pods found with selector app=jaeger\n",
			WantException:  true,
		},
		{ // case 8
			Args:           strings.Split("kiali --browser=false", " "),
			ExpectedOutput: "Error: no pods found with selector app=kiali\n",

    }

    private void injectProxy(ProxySelector selector, List<ArtifactRepository> repositories) {
        if (repositories != null && selector != null) {
            for (ArtifactRepository repository : repositories) {
                repository.setProxy(getProxy(selector, repository));
            }
        }
    }

    private org.apache.maven.repository.Proxy getProxy(ProxySelector selector, ArtifactRepository repository) {

        ModuleComponentSelector selector = (ModuleComponentSelector) dependencyMetaData.getSelector()

        then:
        selector.group == ""
        selector.module == "gradle-core"
        selector.version == ""
        selector.versionConstraint.preferredVersion == ""
    }

    def "test create from module dependency"() {
        when:

	out.Replicas = int32(in.Replicas)
	out.TargetSelector = in.Selector

	out.Selector = nil
	selector, err := metav1.ParseToLabelSelector(in.Selector)
	if err != nil {
		return fmt.Errorf("failed to parse selector: %v", err)
	}
	if len(selector.MatchExpressions) == 0 {
		out.Selector = selector.MatchLabels
	}

	return nil
}

spec:
  ports:
    - port: 9080
      name: tcp
      protocol: TCP
  selector:
    app: details
---
apiVersion: v1
kind: Service
metadata:
  name: details-http-v1
  namespace: bookinfo
  labels:
    app: details
    service: details
spec:
  ports:
    - port: 9080
      name: http
      protocol: HTTP
  selector:
    app: details

---

        ComponentSelector selector,
        @Nullable String dependencyConfiguration,
        List<IvyArtifactName> artifactNames,
        List<ExcludeMetadata> excludes,
        boolean force, boolean changing, boolean transitive,
        boolean constraint, boolean endorsing, boolean fromLock,
        @Nullable String reason
    ) {
        this.selector = selector;