# Reduce Xmx after https://github.com/gradle/gradle-private/issues/4168 is resolved
org.gradle.jvmargs=-Xmx2700m -XX:MaxMetaspaceSize=768m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.caching=true
org.gradle.configuration-cache=true
systemProp.gradle.publish.skip.namespace.check=true
# Kotlin DSL settings
org.gradle.kotlin.dsl.allWarningsAsErrors=true
# Kotlin settings
kotlin.incremental.useClasspathSnapshot=true

    <% if (binding.hasVariable("projectDependencies") && subprojectNumber > 1) { (1..<subprojectNumber).each { %>
        projectsConfiguration project(":project${it}") <% } %>
    <% } %>
}

test {
    jvmArgs '-Xmx1g', '-XX:+HeapDumpOnOutOfMemoryError'
    <% if (binding.hasVariable("fullTestLogging")) { %>
        testLogging {
            if (Boolean.getBoolean("reducedOutput")) {
                events "failed"
            } else {

        String existingArgs = properties.getProperty(ORG_GRADLE_JVMARGS, "");
        properties.setProperty(ORG_GRADLE_JVMARGS, "-Xmx512m -XX:MaxMetaspaceSize=512m -XX:+HeapDumpOnOutOfMemoryError " + existingArgs);
        GUtil.saveProperties(properties, propertiesFile);
    }

    }

    // Testing multibyte escape sequences
    assertEscaping(e, "%00", '\u0000'); // nul
    assertEscaping(e, "%7F", '\u007f'); // del
    assertEscaping(e, "%C2%80", '\u0080'); // xx-00010,x-000000
    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000
    assertEscaping(e, "%EF%BF%BF", '\uffff'); // xxx-1111,x-111111,x-11,1111

// {"Flags":0,"ParamFlags":[0,0],"ResultFlags":null}
// <endcallsites>
// <endfuncpreamble>
func T_hasgotos(x int, y int) {
	{
		xx := x
		panic("bad")
	lab1:
		goto lab2
	lab2:
		if false {
			goto lab1
		} else {
			goto lab4
		}
	lab4:
		if xx < y {
		lab3:
			if false {
				goto lab3
			}
		}
		println(9)
	}
}

// funcflags.go T_break_with_label 246 0 1

            setForkEvery(testForkEvery.toLong())

            if (!JavaVersion.current().isJava8Compatible) {
                jvmArgs("-XX:MaxPermSize=512m")
            }
            jvmArgs("-XX:+HeapDumpOnOutOfMemoryError")
        }

        task<DependencyReportTask>("dependencyReport") {
            outputs.upToDateWhen { false }
            outputFile = buildDir.resolve("dependencies.txt")
        }

            minHeapSize = testRunnerMemory
            maxHeapSize = testRunnerMemory
            maxParallelForks = ${config.maxParallelForks}
            forkEvery = testForkEvery
            jvmArgs '-XX:+HeapDumpOnOutOfMemoryError'
        }

        task dependencyReport(type: DependencyReportTask) {
            outputs.upToDateWhen { false }
            outputFile = new File(buildDir, "dependencies.txt")
        }

            <% } %>
    <% } %>
}

test {
    if (!JavaVersion.current().java8Compatible) {
        jvmArgs '-XX:MaxPermSize=512m'
    }
    jvmArgs '-XX:+HeapDumpOnOutOfMemoryError'
    <% if (binding.hasVariable("fullTestLogging")) { %>
        testLogging {
            events "started", "skipped", "failed", "passed", "standard_out", "standard_error"
        }
    <% } %>

import (
	"fmt"
	"strconv"
	"strings"
)

// PathToPrefix converts raw string to the prefix that will be used in the
// symbol table. All control characters, space, '%' and '"', as well as
// non-7-bit clean bytes turn into %xx. The period needs escaping only in the
// last segment of the path, and it makes for happier users if we escape that as
// little as possible.
func PathToPrefix(s string) string {
	slash := strings.LastIndex(s, "/")

    localRepository.localRepo = configurations["${prefix}TestLocalRepositoryPath"]
}

fun DistributionTest.setJvmArgsOfTestJvm() {
    jvmArgs("-Xmx${project.the<IntegrationTestExtension>().testJvmXmx.get()}", "-XX:+HeapDumpOnOutOfMemoryError")

    val testJavaVersion = JavaLanguageVersion.of(project.testJavaVersion)
    if (!testJavaVersion.canCompileOrRun(8)) {
        jvmArgs("-XX:MaxPermSize=768m")
    }