binDistributionZip.distributionZip = configurations["${prefix}TestBinDistributionPath"]
    allDistributionZip.distributionZip = configurations["${prefix}TestAllDistributionPath"]
    docsDistributionZip.distributionZip = configurations["${prefix}TestDocsDistributionPath"]
    srcDistributionZip.distributionZip = configurations["${prefix}TestSrcDistributionPath"]

        resolver("${prefix}TestAllDistributionPath", "gradle-all-distribution-zip", allDistribution)
        resolver("${prefix}TestDocsDistributionPath", "gradle-docs-distribution-zip", docsDistribution)
        resolver("${prefix}TestSrcDistributionPath", "gradle-src-distribution-zip", srcDistribution)
        resolver("${prefix}TestAgentsClasspath", LibraryElements.JAR)
    }

        val prefix = "${testCoveragePrefix}_"
        val shortenedSubprojectName = shortenSubprojectName(model.projectId, prefix + subProject)
        return model.projectId + "_" + if (subProject.isNotEmpty()) shortenedSubprojectName else "${prefix}0"
    }

    private
    fun shortenSubprojectName(prefix: String, subProjectName: String): String {

        isRelease -> "promoteFinalRelease"
        else -> "promoteFinalBackportRelease"
    }

    private fun nightlyTaskName(prefix: String): String = when {
        isMaster -> "${prefix}Nightly"
        isRelease -> "${prefix}ReleaseNightly"
        else -> "${prefix}PatchReleaseNightly"
    }

            if (groovyImplicitTypes.contains(candidateClassName)) {
                return candidateClassName;
            }
            for (String prefix : groovyImplicitImportPackages) {
                candidateClassName = prefix + name;
                if (isVisibleSystemClass(candidateClassName)) {
                    return candidateClassName;
                }
            }
        }

            return true
        }
        for (prefix in prefixes) {
            if (packageName.startsWith(prefix)) {
                names.add(packageName)
                return true
            }
        }
        return false
    }

import org.gradle.api.tasks.CacheableTask


/**
 * A test that verifies Gradle can be used with popular third party plugins.
 */
@CacheableTask
abstract class SmokeTest : DistributionTest() {
    override val prefix = "smoke"

    }

    public boolean lookingAt(char c) {
        return input.charAt(pos) == c;
    }

    public boolean lookingAt(CharSequence prefix) {
        int i = 0;
        int cpos = pos;
        while (i < prefix.length() && cpos < input.length()) {
            if (prefix.charAt(i) != input.charAt(cpos)) {
                return false;
            }
            i++;
            cpos++;
        }
        return true;

    usesJavadocCodeSnippets.convention(false)
    testJvmXmx.convention("512m")
}

val sourceSet = addSourceSet(TestType.INTEGRATION)
addDependenciesAndConfigurations(TestType.INTEGRATION.prefix)
createTasks(sourceSet, TestType.INTEGRATION)
configureIde(TestType.INTEGRATION)

createTestTask("integMultiVersionTest", "forking", sourceSet, TestType.INTEGRATION) {

                if (list.isNotEmpty()) {
                    append("  $name (").append(list.size).append(")\n")
                    append(list.joinToString(separator = "\n    ", prefix = "    ", postfix = "\n"))
                }
            }
        }.toString()