}
    }

    void configureIncorrectServerCert(GradleExecuter executer) {
        // intentionally use wrong trust store
        def args = getTrustStoreSettings()
            .tap { it["javax.net.ssl.trustStore"] = keyStore.path }
            .collect { "-D${it.key}=${it.value}".toString() }
        if (GradleContextualExecuter.embedded) {
            args.each {
                executer.withArgument(it)

            man.write(jarOut)

            hasConfiguredManifest = true
            this
        }

        private static JarEntry newEntryWithFixedTime(String path) {
            return new JarEntry(path).tap {
                // setTimeLocal() is better but it is Java 9+.
                setTime(CONSTANT_TIME_FOR_ZIP_ENTRIES)
            }
        }

        /**

	statusCmd.PersistentFlags().StringVarP(&configDumpFile, "file", "f", "",
		"Envoy config dump JSON file")
	statusCmd.PersistentFlags().BoolVar(&multiXdsOpts.XdsViaAgents, "xds-via-agents", false,
		"Access Istiod via the tap service of each agent")
	statusCmd.PersistentFlags().IntVar(&multiXdsOpts.XdsViaAgentsLimit, "xds-via-agents-limit", 100,
		"Maximum number of pods being visited by istioctl when `xds-via-agent` flag is true."+

    }

    def <T> T loadToolingLeanModel(Class<T> modelClass, @DelegatesTo(ModelBuilder<T>) Closure configurator = {}) {
        withConnection {
            def builder = it.model(modelClass)
            builder.tap(configurator)
            collectOutputs(builder)
            builder.get()
        }
    }

    def <T> T loadValidatedToolingModel(Class<T> modelClass, @DelegatesTo(ModelBuilder<T>) Closure configurator = {}) {

        run('checkDeadInternalLinks').build()

        then:
        assertNoDeadLinks()
    }

    private File createJavadocForClass(String path) {
        new File(docsRoot, "javadoc/${path}.html").tap {
            parentFile.mkdirs()
            createNewFile()
            text = "Generated javadoc HTML goes here"
        }
    }

    private GradleRunner run(String... args) {

        when:
        hasher.hash(zipContext)

        then:
        1 * delegate.hash(zipContext)
    }

    def "throws IOException generated from hasher"() {
        def file = file('doesNotExist').tap { it.text = "" }
        def delegate = Mock(ResourceHasher)
        def hasher = LineEndingNormalizingResourceHasher.wrap(delegate, LineEndingSensitivity.NORMALIZE_LINE_ENDINGS)
        def snapshotContext = snapshotContext(file)

            it.name.startsWith("gradle-kotlin-dsl-${targetVersion.baseVersion.version}")
        }).content("gradle-kotlin-dsl-versions.properties")
        return new Properties().tap { load(new StringReader(props)) }.getProperty("kotlin")
    }

    protected List<File> canonicalClassPath() {
        return canonicalClassPathFor(projectDir)
    }

    def injectAnnotation = Stub(JApiAnnotation)

    def setup() {
        new File(tmp, "org/gradle/api").mkdirs()
        sourceFile = new File(tmp, "${TEST_INTERFACE_NAME.replace('.', '/')}.java").tap { text = "" }

        jApiClassifier.fullyQualifiedName >> TEST_INTERFACE_NAME
        jApiField.name >> 'field'
        jApiField.jApiClass >> jApiClassifier
        jApiMethod.name >> 'method'

                resArtifacts.set(
                    resolvedArtifacts.map { arts ->
                        arts.collect { art ->
                            objects.newInstance(ResolvedArtifactBean).tap { bean ->
                                bean.file = art.file
                                bean.id = art.id
                                bean.type = art.type
                                bean.variant = art.variant

    private String enumMapToString() {
        "new EnumMap([(SomeEnum.One): 'one', (SomeEnum.Two): 'two'])"
    }

    private String treeMapWithComparator() {
        "new TreeMap({ x, y -> y.compareTo(x) }).tap { putAll([a: 1, b: 2]) }"
    }