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'
}
<% } %>

// 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 {

    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")

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

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

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

     */
    public long getDefaultMaximumHeapSize(long osTotalMemory) {
        if (isIbmJvm()) {
            long totalMemoryHalf = osTotalMemory / 2;
            long halfGB = MemoryAmount.parseNotation("512m");
            return totalMemoryHalf > halfGB ? halfGB : totalMemoryHalf;
        }

        long totalMemoryFourth = osTotalMemory / 4;
        long oneGB = MemoryAmount.parseNotation("1g");

----

To increase the limit to e.g. 512K watches run the following:

[source,bash]
----
echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf
----
[source,bash]
----
sudo sysctl -p --system
----

Each used inotify watch takes up to 1KB of memory.
Assuming inotify uses all the 512K watches then file system watching could use up to 500MB.

        ruleFile = ruleStoreDir.file("stored.rules").asFile
    }

    test {
        // Looks like loading all the classes requires more than the default 512M
        maxHeapSize = "1g"

        // Only use one fork, so freezing doesn't have concurrency issues
        maxParallelForks = 1

        inputs.dir(ruleStoreDir)