osTotalMemory           | bitMode | server | expected
        MemoryAmount.of('512g') | 64      | true   | MemoryAmount.of('32g')
        MemoryAmount.of('8g')   | 64      | true   | MemoryAmount.of('2g')
        MemoryAmount.of('512g') | 64      | false  | MemoryAmount.of('1g')
        MemoryAmount.of('2g')   | 64      | false  | MemoryAmount.of('512m')
        MemoryAmount.of('8g')   | 32      | false  | MemoryAmount.of('1g')

        operation.contentLength = 1024 * 10
        when:
        operation.logProcessedBytes(512 * 0)
        operation.logProcessedBytes(512 * 1)
        then:
        0 * context.progress(_)

        when:
        operation.logProcessedBytes(512 * 1)
        operation.logProcessedBytes(512 * 2)
        then:
        1 * context.progress(1024, 10240, "bytes", "1 KiB/10 KiB downloaded")

    <% if (dependencies) { dependencies.each { %>
        implementation "${it.shortNotation()}" <% } %>
    <% } %>
}

test {
    if (!JavaVersion.current().java8Compatible) {
        jvmArgs '-XX:MaxPermSize=512m'
    }
    jvmArgs '-XX:+HeapDumpOnOutOfMemoryError'
}

<% if (groovyProject) { %>
apply plugin: 'groovy'
dependencies {
    implementation 'org.codehaus:groovy:groovy-all:2.4.15'
}
<% } %>

// compiledir

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 5125: cyclic dependencies between types confuse
// the hashability test during import.

// tag::configure-test-task[]
testing {
    suites {
        integrationTest {
            targets {
                all { // <1>
                    testTask.configure {
                        maxHeapSize = '512m' // <2>
                    }
                }
            }
        }
    }
}

        given:
        buildFile << """
            apply plugin: 'java'
            ${mavenCentralRepository()}
            dependencies { testImplementation 'org.testng:testng:5.12.1' }
            test { useTestNG { suiteThreadPoolSize = 5 } }
        """

        file("src/test/java/SimpleTest.java") << """
            import org.testng.annotations.Test;

            public class SimpleTest {

// run to run. To avoid flakes, this test performs multiple
// experiments and only complains if all of them consistently fail.
func main() {
	// Sample at 16K instead of default 512K to exercise sampling more heavily.
	runtime.MemProfileRate = 16 * 1024

	if err := testInterleavedAllocations(); err != nil {
		panic(err.Error())
	}
	if err := testSmallAllocations(); err != nil {
		panic(err.Error())

    testImplementation("junit:junit:4.13")
    runtimeOnly("com.googlecode:reflectasm:1.01")
}

(tasks.getByName("test") as Test).apply {
    if (!JavaVersion.current().isJava8Compatible) {
        jvmArgs("-XX:MaxPermSize=512m")
    }
    jvmArgs("-XX:+HeapDumpOnOutOfMemoryError")
}

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

	check(mul(zero(), gen(4)), 0)
	check(mul(gen(3), add1(zero())), 3)
	check(mul(add1(zero()), gen(4)), 4)
	check(mul(gen(3), gen(4)), 12)

	check(fact(zero()), 1)
	check(fact(add1(zero())), 1)
	check(fact(gen(5)), 120)
}

// -------------------------------------
// Factorial

var results = [...]int{
	1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800,
	39916800, 479001600,
}

func main() {

            maxParallelForks = ${config.maxParallelForks}
            setForkEvery(testForkEvery.toLong())

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

        task<DependencyReportTask>("dependencyReport") {
            outputs.upToDateWhen { false }