if (!expression) {
      throw new VerifyException();
    }
  }

  /**
   * Ensures that {@code expression} is {@code true}, throwing a {@code VerifyException} with a
   * custom message otherwise.
   *
   * @param expression a boolean expression
   * @param errorMessageTemplate a template for the exception message should the check fail. The

                variant 'customVariant', [format: 'custom']
                dependsOn('org.test:moduleB:1.0')
            }
        }

        buildFile << """
            def testAttribute = Attribute.of("TEST_ATTRIBUTE", String)
            def formatAttribute = Attribute.of('format', String)

            configurations { $variantToTest { attributes { attribute(formatAttribute, 'custom') } } }

            dependencies {

        succeeds("projectReport")

        then:
        file("build/reports/custom/dependencies.txt").assertExists()
        file("build/reports/custom/properties.txt").assertExists()
        file("build/reports/custom/tasks.txt").assertExists()
        file("build/reports/custom/dependencies").assertIsDir()
    }

    def "prints link to default #task"(String task) {
        when:
        succeeds(task)

        then:

                  "properties": [
                     {
                        "id": "custom.fillOpacity",
                        "value": 0
                     },
                     {
                        "id": "custom.lineWidth",
                        "value": 2
                     },
                     {
                        "id": "custom.lineStyle",
                        "value": {
                           "dash": [

# Custom Envoy Bootstrap Configuration

This sample creates a simple helloworld service that bootstraps the Envoy proxy with a custom configuration file.

## Starting the service

First, we need to create a `ConfigMap` resource with our bootstrap configuration.

```bash
kubectl apply -f custom-bootstrap.yaml
```

Next, we can create a service that uses this bootstrap configuration.

        println(launcher.get().metadata.installationPath)
    }

    @get:Inject
    protected abstract val javaToolchainService: JavaToolchainService
}
// end::custom-toolchain-task-with-java[]

// tag::custom-toolchain-task-with-java-usage[]
plugins {
    java
}

java {
    toolchain { // <1>
        languageVersion = JavaLanguageVersion.of(8)
    }
}

        sourceSet.scala.srcDirs == [project.file("src/custom/scala")] as Set
    }

    def addsCompileTaskForNewSourceSet() {
        when:
        project.sourceSets.create('custom')
        SourceSet customSourceSet = project.sourceSets.custom
        def task = project.tasks['compileCustomScala']

        then:
        task instanceof ScalaCompile
        task.description == 'Compiles the custom Scala source.'

        [
            [version: '3', attributes: ['org.gradle.status': 'release', 'custom': 'foo']],
            [version: '2', attributes: ['org.gradle.status': 'integration', 'custom': 'bar']],
            [version: '1', attributes: ['org.gradle.status': 'release', 'custom': 'bar']]
        ]
    )
    private final static String TEST_B_METADATA = new JsonBuilder(
        [

							},
						},
					},
				},
			},
		},
		{
			name: "ISTIO_MUTUAL with custom cert paths from proxy node metadata",
			node: &model.Proxy{
				Metadata: &model.NodeMetadata{
					TLSServerCertChain: "/custom/path/to/cert-chain.pem",
					TLSServerKey:       "/custom-key.pem",
					TLSServerRootCert:  "/custom/path/to/root.pem",
				},
			},
			validateClient: true,
			expected: &auth.CommonTlsContext{

// tag::custom-plugin-repositories[]
pluginManagement {
    repositories {
        maven(url = "./maven-repo")
        gradlePluginPortal()
        ivy(url = "./ivy-repo")
    }
}
// end::custom-plugin-repositories[]