input:    "simple-policy-td-aliases-in.yaml",
			want:     []string{"simple-policy-td-aliases-out.yaml"},
		},
		{
			name:     "trust-domain-multiple-aliases",
			tdBundle: trustdomain.NewBundle("td1", []string{"cluster.local", "some-td"}),
			input:    "simple-policy-multiple-td-aliases-in.yaml",
			want:     []string{"simple-policy-multiple-td-aliases-out.yaml"},
		},
		{

		discovery2.AddInstance(mock.MakeServiceInstance(mock.WorldService, port, 1, model.Locality{}))
	}
	registry1 := serviceregistry.Simple{
		ProviderID:          provider.ID("mockAdapter1"),
		DiscoveryController: discovery1,
	}

	registry2 := serviceregistry.Simple{
		ProviderID:          provider.ID("mockAdapter2"),
		DiscoveryController: discovery2,
	}

	ctls := NewController(Options{&mockMeshConfigHolder{}})

--

There are two, complementary, options to share artifacts between projects.
The <<#sec:simple-sharing-artifacts-between-projects,simplified version>> is only suitable if what you need to share is a simple artifact that doesn't depend on the consumer.
The simple solution is also limited to cases where this artifact is not published to a repository.
This also implies that the consumer does not publish a dependency to this artifact.

	successCases := []map[string]string{
		{"simple": "bar"},
		{"now-with-dashes": "bar"},
		{"1-starts-with-num": "bar"},
		{"1234": "bar"},
		{"simple/simple": "bar"},
		{"now-with-dashes/simple": "bar"},
		{"now-with-dashes/now-with-dashes": "bar"},
		{"now.with.dots/simple": "bar"},
		{"now-with.dashes-and.dots/simple": "bar"},
		{"1-num.2-num/3-num": "bar"},
		{"1234/5678": "bar"},

        parse 'dependency-notations'

        then:
        hasDependency('simple') {
            withGAV('foo', 'bar', '1.0')
        }
        hasDependency('simple-with-rich1') {
            withGroup 'foo'
            withName 'bar'
            withVersion {
                prefer '1.0'
            }
        }
        hasDependency('simple-with-rich2') {
            withGroup 'foo'
            withName 'bar'

		},
	}, func() (generated []test) {
		// Generate test cases for all simple values (0 to 255) because the number of possible simple values is fixed and small.
		for i := 0; i <= 255; i++ {
			each := test{
				name: fmt.Sprintf("simple value %d", i),
			}
			if i <= 23 {
				each.in = []byte{byte(0xe0) | byte(i)}
			} else {
				// larger simple values encode to two bytes
				each.in = []byte{byte(0xe0) | byte(24), byte(i)}

			want:    nil,
		},
		{
			name:    "SIMPLE TLS and nil metadata",
			tlsMode: networking.ClientTLSSettings_SIMPLE,
			meta:    nil,
			want:    alpnOverrideFalse,
		},
		{
			name:    "MUTUAL TLS and nil metadata",
			tlsMode: networking.ClientTLSSettings_SIMPLE,
			meta:    nil,
			want:    alpnOverrideFalse,
		},
		{
			name:    "SIMPLE TLS and empty metadata",

// program unit for which we want to gather coverage info. Coverable
// units are either "simple" or "intraline"; a "simple" coverable unit
// corresponds to a basic block (region of straight-line code with no
// jumps or control transfers). An "intraline" unit corresponds to a
// logical clause nested within some other simple unit. A simple unit
// will have a zero Parent value; for an intraline unit NxStmts will

import java.util.function.Supplier;
import java.util.regex.Pattern;

class DefaultRepositoryContentDescriptor implements RepositoryContentDescriptorInternal {
    private enum MatcherKind {
        SIMPLE,
        REGEX,
        SUB_GROUP,
    }

    private Set<String> includedConfigurations;
    private Set<String> excludedConfigurations;
    private Set<ContentSpec> includeSpecs;

    }

    protected TypeOf() {
        this.type = captureTypeArgument();
    }

    /**
     * Queries whether this object represents a simple (non-composite) type, not an array and not a generic type.
     *
     * @return true if this object represents a simple type.
     */
    public boolean isSimple() {
        return type.isClass()
            && !rawClass().isArray();
    }

    /**