# name or the builder name being non-empty.
#
# GO_TEST_SHORT: if set to a non-empty, false-ish string, run tests in "-short=false" mode.
# This environment variable is an internal implementation detail between the
# Go build system (x/build) and cmd/dist for the purpose of longtest builders,
# and will be removed if it stops being needed. See go.dev/issue/12508.
#
# GO_TEST_TIMEOUT_SCALE: a non-negative integer factor to scale test timeout by.

        executer.requireIsolatedDaemons()
    }

    def "file system watching picks up changes causing a continuous build to rebuild"() {
        given:
        // Do not drop the VFS in the first build, since there is only one continuous build invocation.
        // FileSystemWatchingFixture automatically sets the argument for the first build.
        executer.withArgument(FileSystemWatchingHelper.getDropVfsArgument(false))
        executer.beforeExecute {

        run("copy")
        // force rebuild
        outputDir.file("modified.txt").text = "changed"
        inputDir.forceDeleteDir()
        run("copy")
        then:
        executedAndNotSkipped(":copy")
        outputDir.assertIsEmptyDir()
    }

    def "outputs are cleaned out on rebuild (output type: #type)"() {
        file("buildSrc").deleteDir()

        # copybara:uncomment(OSS version passes this to py_library) lib_rule = py_strict_library,
        deps = [
            ":gen_%s" % name,
        ],
    )

    # Link the register op and rebuild the binary
    gen_tfr_lib_exec = gen_op_lib_exec + "_with_op_library"
    py_strict_binary(
        name = gen_tfr_lib_exec,
        main = src,
        srcs = [src],
        python_version = "PY3",

        InputChangesInternal inputChanges = changes.createInputChanges();
        if (!inputChanges.isIncremental()) {
            LOGGER.info("The input changes require a full rebuild for incremental {}.", work.getDisplayName());
        }
        return inputChanges;
    }

        }
        if (moreChangesCount > 0) {
            logOutput(logger, "and some more changes");
        }
        if (errorWhenWatching) {
            logOutput(logger, "Error when watching files - triggering a rebuild");
        }
    }

    private void showIndividualChange(StyledTextOutput logger, Path path, FileWatcherRegistry.Type changeType) {
        String changeDescription;
        switch (changeType) {

        and:
        outputContains("Input property 'options.annotationProcessorPath' file ${file("annotation/build/libs/annotation.jar").absolutePath} has been removed")
        outputContains("The input changes require a full rebuild for incremental task ':compileJava'")
    }

            }
        """
    }

    def "changing an unused non-private constant incurs full rebuild"() {
        source "class A { int foo() { return 2; } }", "class B { final static int x = 1;}"
        outputs.snapshot { run language.compileTaskName }

        when:
        source "class B { /* change */ }"

However, what happens when the same developer decides to switch to a new branch created last week?
The files are rebuilt, even though the developer is building something that has been built before.

This is where a Build Cache is helpful. The cache stores previous build results, and greatly reduces the need to rebuild things when they have already been built locally.

        'Add Java files to Java file set'           | ['G']        | ['J', 'G']           | ['a full rebuild', "UP-TO-DATE"]                             | ['J', 'G']           | ['UP-TO-DATE', 'UP-TO-DATE']
        'Add Groovy files to Groovy file set'       | ['J']        | ['J', 'G']           | ["UP-TO-DATE", "a full rebuild"]                             | ['J.changed', 'G']   | ['Incremental compilation of', 'UP-TO-DATE']