}
        """)
        versionCatalogFile("""
            [libraries]
            org-example-foo = "${FOO_GROUP}:${FOO_NAME}:${FOO_VERSION}"
            com-example-baz = "${BAZ_GROUP}:${BAZ_NAME}:${BAZ_VERSION}"
            net-example-provider-convertible = "${PVC_GROUP}:${PVC_NAME}:${PVC_VERSION}"
            net-example-provider-convertible-nested = "${PVC_GROUP}:${PVC_NAME}:${PVC_VERSION}"

            [bundles]

	badName := "!@#$%^"
	badValue := "spaces not allowed"
	badAPIGroup := "example.com/v1"
	goodAPIGroup := "example.com"

	scenarios := map[string]struct {
		class        *resource.ResourceClass
		wantFailures field.ErrorList
	}{
		"good-class": {
			class: testClass(goodName, goodName),
		},
		"good-long-driver-name": {
			class: testClass(goodName, "acme.example.com"),
		},
		"missing-name": {

      Route(
        factory.newAddress(uriHost = "example.com", uriPort = 1003),
        Proxy.NO_PROXY,
        InetSocketAddress(ipv4Address, 1003),
      ).toString(),
    ).isEqualTo("example.com at 1.2.3.4:1003")
    assertThat(
      Route(
        factory.newAddress(uriHost = "example.com", uriPort = 1003),
        Proxy(Proxy.Type.HTTP, InetSocketAddress.createUnresolved("proxy.example.com", 1003)),

 *     <li>a fixed value with fixed content, for example a {@code Provider<String>} with a fixed value.</li>
 *     <li>a fixed value with changing content, for example a {@code Provider<RegularFile>} where the file path is hardcoded in a build script or plugin but the file content is built by a task.</li>

		}
	}

	if n := pointerToIndex(certificateForName("example.com")); n != 0 {
		t.Errorf("example.com returned certificate %d, not 0", n)
	}
	if n := pointerToIndex(certificateForName("bar.example.com")); n != 1 {
		t.Errorf("bar.example.com returned certificate %d, not 1", n)
	}
	if n := pointerToIndex(certificateForName("foo.example.com")); n != 2 {
		t.Errorf("foo.example.com returned certificate %d, not 2", n)
	}

=== Using system properties

The following examples demonstrate how to use system properties:

*Example 1:* Setting system properties with a `gradle.properties` file:
====
include::sample[dir="snippets/tutorial/systemProperties/groovy",files="gradle.properties[]"]
====

*Example 2:* Reading system properties at configuration time:
====

    def "can run tests referencing slf4j with modular java"() {
        Assume.assumeTrue(frameworkSupportsModularJava)

        given:
        file('src/test/java/org/gradle/example/TestUsingSlf4j.java') << """
            package org.gradle.example;

            ${testFrameworkImports}

            import org.slf4j.Logger;
            import org.slf4j.LoggerFactory;

            public class TestUsingSlf4j {

    * This generates a collection that has a single value. An example would be some global configuration.
* `func(input I) *O` via `NewCollection`
    * This generates a one-to-one mapping of input to output. An example would be a transformation from a `Pod` type to a generic `Workload` type.
* `func(input I) []O` via `NewManyCollection`

		// no direct match, deeper path ignored
		{"bar.example.com/ping", []AuthConfig{ada}, true},

		// match first part of path token
		{"bar.example.com/pongz", []AuthConfig{grace, ada}, true},

		// match regardless of sub-path
		{"bar.example.com/pong/pang", []AuthConfig{grace, ada}, true},

		// no host match
		{"example.com", []AuthConfig{}, false},
		{"foo.example.com", []AuthConfig{}, false},
	}

    #
    # The following example defines two networks with different endpoints association methods.
    # For `network1` all endpoints that their IP belongs to the provided CIDR range will be
    # mapped to network1. The gateway for this network example is specified by its public IP
    # address and port.
    # The second network, `network2`, in this example is defined differently with all endpoints