@invarn/cibuild 2.9.6 → 2.9.8

package/dist/src/yaml/steps/gradle-memory.test.js

@@ -1,344 +0,0 @@
-/**
- * Gradle's daemon heaps, fitted to the build machine; and a killed daemon,
- * named as one.
- *
- * The fixtures are the `gradle.properties` of IacobIonut01/ReFra
- * (`-Xmx8G`, inherited by the Kotlin daemon) and vitorpamplona/amethyst
- * (`-Xmx6g` beside `kotlin.daemon.jvmargs=-Xmx8g`). Both died on a 10 GiB
- * build machine with nothing in the log but "Gradle build daemon disappeared
- * unexpectedly".
- *
- * The shell under test is the one that ships: it is executed here, not
- * re-implemented.
- */
-import { execFileSync, spawnSync } from "node:child_process";
-import { chmodSync, copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { AndroidBuildForUITestingStepExecutor, AndroidLintStepExecutor, AndroidUnitTestStepExecutor, GradleBuildStepExecutor, } from "./android.js";
-import { GRADLE_MEMORY_FUNCTIONS } from "./gradle-memory.js";
-import { testConfig } from "./test-config.js";
-const FIXTURES = join(dirname(fileURLToPath(import.meta.url)), "../../../test/fixtures/gradle-memory");
-let dir;
-beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "cibuild-gradle-memory-"));
-});
-afterEach(() => {
-    rmSync(dir, { recursive: true, force: true });
-});
-/** Run the shipped plan in `dir`, the way the step does, with a given memory. */
-function plan(memMib, preferred = "", userHome = join(dir, "no-user-home")) {
-    const script = `${GRADLE_MEMORY_FUNCTIONS}
-cibuild_gradle_memory_plan "$1" gradle.properties "$2/gradle.properties" "$3"
-for a in "\${CIBUILD_GRADLE_MEMORY_ARGS[@]}"; do printf 'ARG %s\\n' "$a"; done
-printf 'LINE %s\\n' "$CIBUILD_GRADLE_MEMORY_LINE"
-printf 'SENTENCE %s\\n' "$CIBUILD_GRADLE_MEMORY_SENTENCE"`;
-    const out = execFileSync("bash", ["-c", script, "plan", memMib, userHome, preferred], {
-        cwd: dir,
-        encoding: "utf-8",
-    });
-    const lines = out.split("\n");
-    return {
-        args: lines.filter((l) => l.startsWith("ARG ")).map((l) => l.slice(4)),
-        line: (lines.find((l) => l.startsWith("LINE ")) ?? "").slice(5),
-        sentence: (lines.find((l) => l.startsWith("SENTENCE ")) ?? "").slice(9),
-    };
-}
-const TEN_GIB = "10240";
-describe("cibuild_gradle_memory_plan", () => {
-    test("ReFra: -Xmx8G, inherited by the Kotlin daemon, is capped on a 10 GiB machine", () => {
-        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
-        const p = plan(TEN_GIB);
-        // One heap, the whole 75% of 10 GiB, with Kotlin compiled in it: two
-        // daemons did not fit (split 60/40, ReFra's Kotlin daemon was lost
-        // mid-compile, and the fallback ran out of the Gradle daemon's heap).
-        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7680m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process"]);
-        expect(p.line).toContain("org.gradle.jvmargs=-Xmx8G -Dfile.encoding=UTF-8 at gradle.properties:9");
-        expect(p.line).toContain("16.0 GiB");
-        expect(p.line).toContain("Running with Gradle -Xmx7680m and Kotlin compiled in-process in it (kotlin.compiler.execution.strategy=in-process: one heap, not a Gradle and a Kotlin daemon), set on the command line.");
-        expect(p.sentence).toMatch(/^The build machine has 10\.0 GiB; this build's Gradle and Kotlin daemons asked for 16\.0 GiB/);
-        expect(p.sentence).toMatch(/This build ran them capped: Gradle -Xmx7680m and Kotlin compiled in-process in it .*\.$/);
-    });
-    test("ReFra on its 9.7 GiB build guest", () => {
-        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
-        expect(plan("9933").args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7424m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process"]);
-    });
-    test("mifos-mobile on its 6 GiB mac guest gets the one heap too", () => {
-        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx6g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:MaxMetaspaceSize=1g\n");
-        expect(plan("6144").args).toEqual([
-            // Its Kotlin daemon inherited the 1g Metaspace cap; in one JVM the cap holds both.
-            "-Dorg.gradle.jvmargs=-Xmx4608m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:MaxMetaspaceSize=2048m",
-            "-Pkotlin.compiler.execution.strategy=in-process",
-        ]);
-    });
-    // GetStream/whatsApp-clone-compose (nightly-baseline 79): Gradle capped at
-    // 512m Metaspace and Kotlin given 1g of its own; in-process, the one JVM
-    // ran out of Metaspace in compileDebugKotlin.
-    test("whatsApp-clone-compose: a Metaspace cap holds Kotlin's too once Kotlin is in-process", () => {
-        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx4g -XX:+HeapDumpOnOutOfMemoryError -XX:+UseParallelGC -XX:MaxMetaspaceSize=512m -Dkotlin.daemon.jvm.options=-XX:MaxMetaspaceSize=1g -Dlint.nullness.ignore-deprecated=true\n");
-        const p = plan("9933");
-        expect(p.args).toEqual([
-            "-Dorg.gradle.jvmargs=-Xmx7424m -XX:+HeapDumpOnOutOfMemoryError -XX:+UseParallelGC -XX:MaxMetaspaceSize=1536m -Dkotlin.daemon.jvm.options=-XX:MaxMetaspaceSize=1g -Dlint.nullness.ignore-deprecated=true",
-            "-Pkotlin.compiler.execution.strategy=in-process",
-        ]);
-        expect(p.line).toContain("with -XX:MaxMetaspaceSize=1536m (Gradle's 512m and Kotlin's 1024m, in one JVM now)");
-    });
-    test("a Kotlin daemon with no Metaspace of its own inherits Gradle's, and the cap doubles", () => {
-        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx8g -XX:MaxMetaspaceSize=1g\n");
-        expect(plan(TEN_GIB).args[0]).toBe("-Dorg.gradle.jvmargs=-Xmx7680m -XX:MaxMetaspaceSize=2048m");
-    });
-    test("the one heap never goes below 512 MiB", () => {
-        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx4g\n");
-        expect(plan("600").args).toEqual(["-Dorg.gradle.jvmargs=-Xmx512m", "-Pkotlin.compiler.execution.strategy=in-process"]);
-    });
-    test("amethyst: a Kotlin daemon with its own -Xmx is compiled in-process too, in one heap", () => {
-        copyFileSync(join(FIXTURES, "amethyst.gradle.properties"), join(dir, "gradle.properties"));
-        const p = plan(TEN_GIB);
-        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7680m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process"]);
-        expect(p.line).toContain("kotlin.daemon.jvmargs=-Xmx8g -XX:MaxMetaspaceSize=2g at gradle.properties:27");
-        expect(p.line).toContain("14.0 GiB");
-    });
-    test("heaps that fit are left alone, and nothing is printed", () => {
-        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
-        const p = plan("65536");
-        expect(p.args).toEqual([]);
-        expect(p.line).toBe("");
-        expect(p.sentence).toContain("asked for 16.0 GiB");
-    });
-    test("a project that declares nothing gets Gradle's default and no cap", () => {
-        const p = plan(TEN_GIB);
-        expect(p.args).toEqual([]);
-        expect(p.sentence).toContain("Gradle's default -Xmx512m");
-    });
-    test("in-process Kotlin compilation has no Kotlin daemon to count", () => {
-        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx4g\nkotlin.compiler.execution.strategy=in-process\n");
-        expect(plan("6144").args).toEqual([]);
-        expect(plan("4096").args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3072m"]);
-    });
-    test("the Gradle user home's value wins over the project's, as in Gradle", () => {
-        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx1g\n");
-        const home = join(dir, "home");
-        mkdirSync(home);
-        writeFileSync(join(home, "gradle.properties"), "org.gradle.jvmargs=-Xmx6g -XX:+UseParallelGC\n");
-        const p = plan(TEN_GIB, "", home);
-        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7680m -XX:+UseParallelGC", "-Pkotlin.compiler.execution.strategy=in-process"]);
-        expect(p.line).toContain(`at ${home}/gradle.properties:1`);
-    });
-    test("JVM arguments the pipeline asks for replace the project's, and are still capped", () => {
-        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
-        const fits = plan(TEN_GIB, "-Xmx2g -Dfile.encoding=UTF-8");
-        expect(fits.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx2g -Dfile.encoding=UTF-8"]);
-        expect(fits.line).toContain("as the pipeline asks");
-        const capped = plan("4096", "-Xmx4g -Dfile.encoding=UTF-8");
-        expect(capped.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3072m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process"]);
-        expect(capped.line).toContain("at the pipeline");
-    });
-    test("a value continued onto another line is left as it is, and says so", () => {
-        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx12g \\\n  -Dfile.encoding=UTF-8\n");
-        const p = plan(TEN_GIB);
-        expect(p.args).toEqual([]);
-        expect(p.line).toContain("continues onto another line");
-    });
-    test("an unknown machine size caps nothing", () => {
-        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
-        const p = plan("");
-        expect(p.args).toEqual([]);
-        expect(p.sentence).toContain("could not be read");
-    });
-    test("-Xmx in every unit, and a comment is not an assignment", () => {
-        writeFileSync(join(dir, "gradle.properties"), "# org.gradle.jvmargs=-Xmx64g\norg.gradle.jvmargs = -Xms1g -Xmx6144m\nkotlin.daemon.jvmargs:-Xmx4194304k\n");
-        const p = plan("8192");
-        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xms1g -Xmx6144m", "-Pkotlin.compiler.execution.strategy=in-process"]);
-    });
-});
-/** The plan, then the workers plan, as the step runs them. */
-function workersPlan(memMib, maxWorkers) {
-    const script = `${GRADLE_MEMORY_FUNCTIONS}
-cibuild_gradle_memory_plan "$1" gradle.properties "$2/gradle.properties" ""
-cibuild_gradle_workers_plan "$3"
-for a in "\${CIBUILD_GRADLE_MEMORY_ARGS[@]}"; do printf 'ARG %s\\n' "$a"; done
-printf 'LINE %s\\n' "$CIBUILD_GRADLE_WORKERS_LINE"
-printf 'SENTENCE %s\\n' "$CIBUILD_GRADLE_MEMORY_SENTENCE"`;
-    const out = execFileSync("bash", ["-c", script, "plan", memMib, join(dir, "no-user-home"), maxWorkers], {
-        cwd: dir,
-        encoding: "utf-8",
-    });
-    const lines = out.split("\n");
-    return {
-        args: lines.filter((l) => l.startsWith("ARG ")).map((l) => l.slice(4)),
-        line: (lines.find((l) => l.startsWith("LINE ")) ?? "").slice(5),
-        sentence: (lines.find((l) => l.startsWith("SENTENCE ")) ?? "").slice(9),
-    };
-}
-// ReFra was killed again with its heap capped: off-heap memory and parallel
-// native compilers are past what a heap cap bounds. Its CI also sets
-// org.gradle.workers.max=2, which the pipeline carries as max_workers.
-// nightly-baseline 83: SEAbdulbasit/MusicApp-KMP pins its developer's JDK in
-// gradle.properties, and Gradle refused to start.
-describe("cibuild_gradle_java_home_plan", () => {
-    const javaHomePlan = (env) => {
-        const out = execFileSync("bash", ["-c", `${GRADLE_MEMORY_FUNCTIONS}
-CIBUILD_GRADLE_MEMORY_ARGS=()
-cibuild_gradle_java_home_plan gradle.properties "$1/gradle.properties"
-for a in "\${CIBUILD_GRADLE_MEMORY_ARGS[@]}"; do printf 'ARG %s\\n' "$a"; done
-printf 'LINE %s\\n' "$CIBUILD_GRADLE_JAVA_HOME_LINE"`, "plan", join(dir, "no-user-home")], { cwd: dir, encoding: "utf-8", env: { PATH: process.env.PATH ?? "", ...env } });
-        const lines = out.split("\n");
-        return {
-            args: lines.filter((l) => l.startsWith("ARG ")).map((l) => l.slice(4)),
-            line: (lines.find((l) => l.startsWith("LINE ")) ?? "").slice(5),
-        };
-    };
-    test("a pinned JDK that is not on this machine is replaced by the build's", () => {
-        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx2g\norg.gradle.java.home=/Users/abdulbasit/Library/Java/JavaVirtualMachines/corretto-21.0.3/Contents/Home\n");
-        const p = javaHomePlan({ JAVA_HOME: dir });
-        expect(p.args).toEqual([`-Dorg.gradle.java.home=${dir}`]);
-        expect(p.line).toContain("org.gradle.java.home=/Users/abdulbasit/Library/Java/JavaVirtualMachines/corretto-21.0.3/Contents/Home at gradle.properties:2 is not on this machine");
-    });
-    test("a pinned JDK that exists is left alone", () => {
-        writeFileSync(join(dir, "gradle.properties"), `org.gradle.java.home=${dir}\n`);
-        expect(javaHomePlan({ JAVA_HOME: "/elsewhere" }).args).toEqual([]);
-    });
-    test("no pin, nothing", () => {
-        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx2g\n");
-        expect(javaHomePlan({ JAVA_HOME: dir })).toEqual({ args: [], line: "" });
-    });
-});
-describe("cibuild_gradle_workers_plan", () => {
-    test("ReFra: the worker count goes after the heap cap, and the sentence names it", () => {
-        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
-        const p = workersPlan(TEN_GIB, "2");
-        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7680m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process", "--max-workers=2"]);
-        expect(p.line).toBe("Gradle memory: running with --max-workers=2, as the pipeline asks (set on the command line, over any org.gradle.workers.max).");
-        expect(p.sentence).toMatch(/This build ran them capped: Gradle -Xmx7680m and Kotlin compiled in-process in it .* Gradle ran with --max-workers=2\.$/);
-    });
-    test("heaps that fit still get the worker count", () => {
-        const p = workersPlan(TEN_GIB, "4");
-        expect(p.args).toEqual(["--max-workers=4"]);
-    });
-    test("nothing asked, nothing passed or printed", () => {
-        const p = workersPlan(TEN_GIB, "");
-        expect(p.args).toEqual([]);
-        expect(p.line).toBe("");
-        expect(p.sentence).not.toContain("max-workers");
-    });
-    test.each(["0", "02", "-1", "two", "2 --offline"])("%s is not a worker count, and says so", (value) => {
-        const p = workersPlan(TEN_GIB, value);
-        expect(p.args).toEqual([]);
-        expect(p.line).toBe(`Gradle memory: max_workers=${value} is not a positive whole number, so it is not passed and Gradle picks its own worker count.`);
-    });
-});
-/** A directory standing in for PATH, with a fake `dmesg` that prints `oom`. */
-function fakeBin(oom) {
-    const bin = join(dir, "bin");
-    mkdirSync(bin, { recursive: true });
-    writeFileSync(join(bin, "dmesg"), `#!/bin/bash\nprintf '%s\\n' ${JSON.stringify(oom)}\n`);
-    chmodSync(join(bin, "dmesg"), 0o755);
-    return bin;
-}
-/** A `./gradlew` that records its arguments and fails the way it is told. */
-function fakeGradlew(body) {
-    writeFileSync(join(dir, "gradlew"), `#!/bin/bash\nprintf '%s\\n' "$@" > "$(dirname "$0")/gradlew-args"\n${body}\n`);
-    chmodSync(join(dir, "gradlew"), 0o755);
-}
-function runStep(script, bin) {
-    writeFileSync(join(dir, "step.sh"), script);
-    return spawnSync("bash", [join(dir, "step.sh")], {
-        cwd: dir,
-        encoding: "utf-8",
-        env: { ...process.env, PATH: `${bin}:${process.env.PATH}`, JAVA_HOME: "", CIBUILD_SOURCE_DIR: "" },
-    });
-}
-describe("the Gradle steps", () => {
-    const OOM_LINE = "[  412.9] Out of memory: Killed process 4242 (java) total-vm:14680064kB, anon-rss:9437184kB";
-    test("a killed daemon prints the kernel's out-of-memory lines and the sentence, and still fails", async () => {
-        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
-        fakeGradlew('echo "FAILURE: Build failed with an exception."\necho "Gradle build daemon disappeared unexpectedly (it may have been killed or may have crashed)"\nexit 1');
-        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug" }, {}, testConfig);
-        const run = runStep(step.script, fakeBin(OOM_LINE));
-        expect(run.status).toBe(1);
-        expect(run.stdout).toContain("Gradle memory: a Gradle daemon was killed rather than failing the build (exit 1).");
-        expect(run.stdout).toContain(`    ${OOM_LINE}`);
-        expect(run.stdout).toMatch(/The build machine has [0-9.]+ GiB; this build's Gradle and Kotlin daemons asked for 16\.0 GiB/);
-        expect(run.stdout).not.toContain("Gradle build completed successfully");
-    });
-    test("a lost Kotlin daemon is named like a killed Gradle daemon", async () => {
-        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
-        // ReFra, bld_bd0132cc5229acb16c54130f: KGP's words, then its fallback.
-        fakeGradlew('echo "e: Daemon compilation failed"\necho "org.jetbrains.kotlin.gradle.tasks.DaemonCrashedException: Connection to the Kotlin daemon has been unexpectedly lost. This might be caused by the daemon being killed by another process or the operating system, or by JVM crash."\necho "Using fallback strategy: Compile without Kotlin daemon"\nexit 1');
-        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug" }, {}, testConfig);
-        const run = runStep(step.script, fakeBin(OOM_LINE));
-        expect(run.status).toBe(1);
-        expect(run.stdout).toContain("Gradle memory: the Kotlin daemon was lost mid-compile rather than the build failing (exit 1). Kotlin then compiled without it, in the Gradle daemon's heap.");
-        expect(run.stdout).toContain(`    ${OOM_LINE}`);
-        expect(run.stdout).toMatch(/The build machine has [0-9.]+ GiB; this build's Gradle and Kotlin daemons asked for 16\.0 GiB/);
-    });
-    test("an ordinary failure says nothing about memory", async () => {
-        fakeGradlew('echo "Compilation error"\nexit 1');
-        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug" }, {}, testConfig);
-        const run = runStep(step.script, fakeBin(OOM_LINE));
-        expect(run.status).toBe(1);
-        expect(run.stdout).not.toContain("Gradle memory:");
-    });
-    test("the pipeline's jvmargs reach Gradle as one argument, before the task", async () => {
-        fakeGradlew("exit 0");
-        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug", gradle_options: "--stacktrace", jvmargs: "-Xmx256m -Dfile.encoding=UTF-8" }, {}, testConfig);
-        const run = runStep(step.script, fakeBin(""));
-        expect(run.status).toBe(0);
-        const args = execFileSync("cat", [join(dir, "gradlew-args")], { encoding: "utf-8" }).trim().split("\n");
-        expect(args).toEqual(["-Dorg.gradle.jvmargs=-Xmx256m -Dfile.encoding=UTF-8", "assembleDebug", "--stacktrace"]);
-    });
-    test("the pipeline's max_workers reach Gradle after the heap arguments, before the task", async () => {
-        fakeGradlew("exit 0");
-        const step = await new GradleBuildStepExecutor().execute(
-        // YAML reads `max_workers: 2` as a number.
-        { gradle_task: "assembleDebug", gradle_options: "--stacktrace", jvmargs: "-Xmx256m", max_workers: 2 }, {}, testConfig);
-        const run = runStep(step.script, fakeBin(""));
-        expect(run.status).toBe(0);
-        expect(run.stdout).toContain("Gradle memory: running with --max-workers=2, as the pipeline asks");
-        const args = execFileSync("cat", [join(dir, "gradlew-args")], { encoding: "utf-8" }).trim().split("\n");
-        expect(args).toEqual(["-Dorg.gradle.jvmargs=-Xmx256m", "--max-workers=2", "assembleDebug", "--stacktrace"]);
-    });
-    test("a killed daemon's sentence names the worker count it ran with", async () => {
-        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
-        fakeGradlew('echo "Gradle build daemon disappeared unexpectedly"\nexit 1');
-        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug", max_workers: "2" }, {}, testConfig);
-        const run = runStep(step.script, fakeBin(OOM_LINE));
-        expect(run.status).toBe(1);
-        // The test machine's own memory decides whether a cap applied, so only the
-        // sentence's end is asserted.
-        expect(run.stdout).toMatch(/^The build machine has .*asked for 16\.0 GiB .* Gradle ran with --max-workers=2\.$/m);
-    });
-    test("every Gradle step passes max_workers to the plan", async () => {
-        const steps = [
-            await new GradleBuildStepExecutor().execute({ max_workers: 3 }, {}, testConfig),
-            await new AndroidLintStepExecutor().execute({ max_workers: 3 }, {}, testConfig),
-            await new AndroidUnitTestStepExecutor().execute({ max_workers: 3 }, {}, testConfig),
-            await new AndroidBuildForUITestingStepExecutor().execute({ max_workers: 3 }, {}, testConfig),
-        ];
-        for (const step of steps) {
-            expect(step.script).toContain("cibuild_gradle_memory_cap '' '3'");
-        }
-    });
-    test("every Gradle step runs through the plan, and every one is valid bash", async () => {
-        const steps = [
-            await new GradleBuildStepExecutor().execute({}, {}, testConfig),
-            await new AndroidLintStepExecutor().execute({}, {}, testConfig),
-            await new AndroidUnitTestStepExecutor().execute({}, {}, testConfig),
-            await new AndroidBuildForUITestingStepExecutor().execute({}, {}, testConfig),
-        ];
-        for (const step of steps) {
-            const script = step.script;
-            expect(script).toContain("cibuild_gradle_memory_cap '' ''");
-            execFileSync("bash", ["-n"], { input: script });
-        }
-    });
-    // cibuild's log is parsed for step-progress markers; nothing here may look
-    // like one.
-    test("no line the functions print can be taken for a step-progress marker", () => {
-        for (const line of GRADLE_MEMORY_FUNCTIONS.split("\n")) {
-            expect(line).not.toMatch(/INVARN_(STEP|PHASE)|▸/);
-        }
-    });
-});
-//# sourceMappingURL=gradle-memory.test.js.map

package/dist/src/yaml/steps/gradle-sdk-cmake.d.ts

@@ -1,28 +0,0 @@
-/**
- * The SDK CMake a build file pins, installed before Gradle runs.
- *
- * A module may pin its CMake (`android { externalNativeBuild { cmake {
- * version = "3.31.6" } } }`). AGP downloads a pinned CMake it lacks, but only
- * when it configures CMake, and a build's own Gradle task can need it first.
- * IacobIonut01/ReFra's `buildHeifEncodeNative*` tasks run
- * `scripts/native/build-heif-encode.sh`, which requires
- * `$SDK/cmake/3.31.6/bin/cmake` and stops with "cmake 3.31.6 not found". The
- * build images bake no SDK CMake, and a runner image cannot carry every
- * version, so the version the project pins is installed with the SDK's own
- * `sdkmanager` (its licences are accepted when the image is baked).
- *
- * Only literal versions inside a `cmake { }` block count. When there is no SDK
- * or no sdkmanager, or the install fails, one line says so and the step goes
- * on: AGP may still manage on its own.
- *
- * Written as shell functions so what ships is what the tests run. The shell
- * is a raw string with no `${`, so every escape here is the one bash and awk
- * read. Its lines start with "Android SDK:", never with a step-progress marker.
- */
-export declare const GRADLE_SDK_CMAKE_FUNCTIONS: string;
-/**
- * The commands a Gradle step runs in the project directory before Gradle, so
- * a CMake the project pins is in the SDK when its own tasks look for it.
- */
-export declare function gradleSdkCmakeCommands(): string[];
-//# sourceMappingURL=gradle-sdk-cmake.d.ts.map

package/dist/src/yaml/steps/gradle-sdk-cmake.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gradle-sdk-cmake.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/gradle-sdk-cmake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,eAAO,MAAM,0BAA0B,QA6ErC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD"}

package/dist/src/yaml/steps/gradle-sdk-cmake.js

@@ -1,107 +0,0 @@
-/**
- * The SDK CMake a build file pins, installed before Gradle runs.
- *
- * A module may pin its CMake (`android { externalNativeBuild { cmake {
- * version = "3.31.6" } } }`). AGP downloads a pinned CMake it lacks, but only
- * when it configures CMake, and a build's own Gradle task can need it first.
- * IacobIonut01/ReFra's `buildHeifEncodeNative*` tasks run
- * `scripts/native/build-heif-encode.sh`, which requires
- * `$SDK/cmake/3.31.6/bin/cmake` and stops with "cmake 3.31.6 not found". The
- * build images bake no SDK CMake, and a runner image cannot carry every
- * version, so the version the project pins is installed with the SDK's own
- * `sdkmanager` (its licences are accepted when the image is baked).
- *
- * Only literal versions inside a `cmake { }` block count. When there is no SDK
- * or no sdkmanager, or the install fails, one line says so and the step goes
- * on: AGP may still manage on its own.
- *
- * Written as shell functions so what ships is what the tests run. The shell
- * is a raw string with no `${`, so every escape here is the one bash and awk
- * read. Its lines start with "Android SDK:", never with a step-progress marker.
- */
-export const GRADLE_SDK_CMAKE_FUNCTIONS = String.raw `# The CMake versions the project's build files pin, one per line as
-# "<file>:<line><TAB><version>", first pin of each version only. Build
-# outputs, .git and .gradle are not read.
-cibuild_pinned_cmake_versions() {
-  find . \( -name build -o -name .git -o -name .gradle -o -name node_modules \) -prune -o \
-    -type f \( -name build.gradle -o -name build.gradle.kts \) -print 2>/dev/null | sort |
-  while IFS= read -r f; do
-    awk -v file="$f" '
-      FNR == 1 { inblk = 0; depth = 0 }
-      {
-        line = $0
-        sub(/\/\/.*$/, "", line)
-        if (!inblk && line ~ /(^|[^A-Za-z0-9_])cmake[ \t]*\{/) {
-          inblk = 1; depth = 0
-          sub(/.*(^|[^A-Za-z0-9_])cmake[ \t]*\{/, "{", line)
-        }
-        if (!inblk) next
-        if (match(line, /(^|[^A-Za-z0-9_.])version[ \t]*=?[ \t]*["\047][0-9]+\.[0-9]+(\.[0-9]+)?["\047]/)) {
-          v = substr(line, RSTART, RLENGTH); sub(/^.*version/, "", v); gsub(/[^0-9.]/, "", v)
-          print file ":" FNR "\t" v
-        }
-        depth += gsub(/\{/, "{", line) - gsub(/\}/, "}", line)
-        if (depth <= 0) inblk = 0
-      }
-    ' "$f"
-  done | awk -F '\t' '!seen[$2]++'
-}
-
-# The Android SDK: ANDROID_HOME, then ANDROID_SDK_ROOT, then local.properties'
-# sdk.dir. Prints nothing when none names a directory.
-cibuild_android_sdk_dir() {
-  local d
-  for d in "$ANDROID_HOME" "$ANDROID_SDK_ROOT"; do
-    if [ -n "$d" ] && [ -d "$d" ]; then echo "$d"; return 0; fi
-  done
-  if [ -f local.properties ]; then
-    d=$(sed -n 's/^[ \t]*sdk\.dir[ \t]*[=:][ \t]*//p' local.properties | tail -n 1 | sed 's/[ \t\r]*$//')
-    if [ -n "$d" ] && [ -d "$d" ]; then echo "$d"; return 0; fi
-  fi
-  return 0
-}
-
-# Installs every pinned CMake the SDK does not have. Never fails the step.
-cibuild_install_pinned_cmake() {
-  local pins sdk sdkmanager at v out rc
-  pins=$(cibuild_pinned_cmake_versions)
-  [ -n "$pins" ] || return 0
-  sdk=$(cibuild_android_sdk_dir)
-  sdkmanager=""
-  if [ -n "$sdk" ] && [ -x "$sdk/cmdline-tools/latest/bin/sdkmanager" ]; then
-    sdkmanager="$sdk/cmdline-tools/latest/bin/sdkmanager"
-  elif [ -n "$sdk" ] && command -v sdkmanager >/dev/null 2>&1; then
-    sdkmanager=$(command -v sdkmanager)
-  fi
-  while IFS='	' read -r at v; do
-    if [ -n "$sdk" ] && [ -x "$sdk/cmake/$v/bin/cmake" ]; then continue; fi
-    if [ -z "$sdk" ]; then
-      echo "Android SDK: $at pins cmake;$v, but no Android SDK was found (ANDROID_HOME, ANDROID_SDK_ROOT, local.properties sdk.dir), so it is not installed here."
-      continue
-    fi
-    if [ -z "$sdkmanager" ]; then
-      echo "Android SDK: $at pins cmake;$v, but $sdk has no sdkmanager, so it is not installed here."
-      continue
-    fi
-    echo "Android SDK: installing cmake;$v, which $at pins (externalNativeBuild cmake version) and this SDK does not have."
-    # Licences are answered from a process substitution, not a pipe, so
-    # neither set -e nor pipefail turns yes's SIGPIPE into a failure.
-    rc=0
-    out=$("$sdkmanager" "--sdk_root=$sdk" "cmake;$v" < <(yes 2>/dev/null) 2>&1) || rc=$?
-    if [ "$rc" -eq 0 ] && [ -x "$sdk/cmake/$v/bin/cmake" ]; then
-      echo "Android SDK: cmake;$v installed."
-    else
-      echo "Android SDK: installing cmake;$v failed (sdkmanager exit $rc); Gradle runs anyway:"
-      printf '%s\n' "$out" | tail -n 5 | sed 's/^/    /'
-    fi
-  done <<< "$pins"
-  return 0
-}`;
-/**
- * The commands a Gradle step runs in the project directory before Gradle, so
- * a CMake the project pins is in the SDK when its own tasks look for it.
- */
-export function gradleSdkCmakeCommands() {
-    return ['', GRADLE_SDK_CMAKE_FUNCTIONS, '', 'cibuild_install_pinned_cmake'];
-}
-//# sourceMappingURL=gradle-sdk-cmake.js.map

package/dist/src/yaml/steps/gradle-sdk-cmake.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=gradle-sdk-cmake.test.d.ts.map

package/dist/src/yaml/steps/gradle-sdk-cmake.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gradle-sdk-cmake.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/gradle-sdk-cmake.test.ts"],"names":[],"mappings":""}