def project = projects.empty ? new TestProject("root", this) : new TestProject("project${projects.size()}", this, projects.size())
            projects << project
        }

        ant.delete(dir: destDir)
        destDir.mkdirs()

        gradlebuild.performance.generator.MavenRepository repo = generateDependencyRepository()
        generateRootProject()
        subprojects.each { subproject ->
            if (repo) {

import java.util.concurrent.atomic.AtomicBoolean;

import static org.gradle.testkit.runner.TaskOutcome.FAILED;
import static org.gradle.testkit.runner.TaskOutcome.FROM_CACHE;
import static org.gradle.testkit.runner.TaskOutcome.NO_SOURCE;
import static org.gradle.testkit.runner.TaskOutcome.SKIPPED;
import static org.gradle.testkit.runner.TaskOutcome.SUCCESS;
import static org.gradle.testkit.runner.TaskOutcome.UP_TO_DATE;

            into(destDir)
            expand([
                rootProjectName: name,
                subprojects: subprojectNames
            ])
        }
    }

    void generateGradleProperties() {
        project.copy{
            from(new File(resolveTemplate("gradle-properties"), "gradle.properties"))
            into(destDir)
            expand([

    public String getDestPath() {
        return destDir == null ? null : PATH_NOTATION_PARSER.parseNotation(destDir);
    }

    @Override
    @Nullable
    public File getDestinationDir() {
        if (destDir instanceof File) {
            return (File) destDir;
        } else {
            return destDir == null ? null : new File(PATH_NOTATION_PARSER.parseNotation(destDir));
        }
    }

    @Override

import org.gradle.testkit.runner.GradleRunner
import org.gradle.util.internal.TextUtil
import spock.lang.Issue
import spock.lang.TempDir

@Requires(UnitTestPreconditions.NotWindows)
class ConfigurationCacheTestKitIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    @TempDir
    File jacocoDestinationDir

	}
	p := NewPrefixTransformers(testErr, transformers...)

	testCases := []struct {
		input  []byte
		expect []byte
		stale  bool
		err    error
		match  int
	}{
		{[]byte("first:value"), []byte("value1"), false, nil, 0},
		{[]byte("second:value"), []byte("value2"), true, nil, 1},
		{[]byte("third:value"), nil, false, testErr, -1},
		{[]byte("fails:value"), nil, false, transformErr, 2},

 */

package org.gradle.testkit.runner

import org.gradle.internal.nativeintegration.ProcessEnvironment
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.testfixtures.internal.NativeServicesTestFixture
import org.gradle.testkit.runner.fixtures.InjectsPluginClasspath
import org.gradle.testkit.runner.fixtures.InspectsBuildOutput

	}{
		{1 << (UintSize - 1), 2, 1, 0, 1},
		{_M, _M, _M - 1, 1, 42},
	} {
		testMul("Mul", Mul, a.x, a.y, a.hi, a.lo)
		testMul("Mul symmetric", Mul, a.y, a.x, a.hi, a.lo)
		testDiv("Div", Div, a.hi, a.lo+a.r, a.y, a.x, a.r)
		testDiv("Div symmetric", Div, a.hi, a.lo+a.r, a.x, a.y, a.r)
		// The above code can't test intrinsic implementation, because the passed function is not called directly.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.testkit.runner;

import org.gradle.api.Incubating;
import org.gradle.testkit.runner.internal.DefaultGradleRunner;

import javax.annotation.Nullable;
import java.io.File;
import java.io.Writer;
import java.net.URI;
import java.util.List;

		return 0, err
	}
	argvp, err := SlicePtrFromStrings(argv)
	if err != nil {
		return 0, err
	}

	destDir := attr.Dir
	if destDir == "" {
		wdmu.Lock()
		destDir = wdStr
		wdmu.Unlock()
	}
	var dir *byte
	if destDir != "" {
		dir, err = BytePtrFromString(destDir)
		if err != nil {
			return 0, err
		}
	}
	var envvParsed []envItem
	if attr.Env != nil {