This is where a *build cache* is helpful.

The build cache stores previous build results and restores them when needed.
It prevents the redundant work and cost of executing time-consuming and expensive processes.

When the build cache has been used to repopulate the local directory, the tasks are marked as `FROM-CACHE`:

[source,text]
----
$ ./gradlew compileJava --build-cache

        installation("build/install/main").exec().out == "CPP_C"
    }

    @Issue("GRADLE-2925")
    @ToBeFixedForConfigurationCache
    def "headers for source set added to library binary are available to consuming binary"() {
        def app = new CppHelloWorldApp()
        given:
        buildFile << """
apply plugin: "cpp"

model {
    components {
        main(NativeExecutableSpec) {
            sources {

     * <li>{@link SortOrder#CONSUMER_FIRST} : Artifacts for a consuming component should appear before artifacts for its dependencies.</li>
     * <li>{@link SortOrder#DEPENDENCY_FIRST} : Artifacts for a consuming component should appear after artifacts for its dependencies.</li>
     * </ul>

    if (!input_type.hasRank() || !output_type.hasRank()) return failure();

    // The pattern attempts to reduce the rank of the input to BroadcastTo.
    // Thus, we fail to match if the consuming reshape rank is larger.
    ArrayRef<int64_t> input_shape = input_type.getShape();
    if (reshape_shape.size() > input_shape.size()) return failure();

    // Extend the input shape with leading 1s to match the broadcast shape.

include::component_metadata_rules.adoc[leveloffset=+2]
include::resolution_rules.adoc[leveloffset=+2]
include::resolution_strategy_tuning.adoc[leveloffset=+2]

== PRODUCING AND CONSUMING VARIANTS OF LIBRARIES

include::component_capabilities.adoc[leveloffset=+2]
include::feature_variants.adoc[leveloffset=+2]
include::variant_model.adoc[leveloffset=+2]
include::variant_attributes.adoc[leveloffset=+2]

// length-prefixed, binary messages, including ASN.1 DER. (The asn1 subpackage
// contains useful ASN.1 constants.)
//
// The String type is for parsing. It wraps a []byte slice and provides helper
// functions for consuming structures, value by value.
//
// The Builder type is for constructing messages. It providers helper functions
// for appending values and also for appending length-prefixed submessages –

         * Never empty.
         * Null if the task has no inputs.
         */
        @Nullable
        Map<String, byte[]> getInputValueHashesBytes();

        /**
         * The consuming visitor for file property inputs.
         * <p>
         * Properties are visited depth-first lexicographical.
         * Roots are visited in semantic order (i.e. the order in which they make up the file collection)

      }
    } else {
      LLVM_DEBUG(llvm::dbgs()
                 << "No supported special parent found, using "
                    "tf_device.cluster_func outputs directly to search for "
                    "consuming AssignVariableOp.\n");
    }
  }
  return llvm::dyn_cast_or_null<TF::AssignVariableOp>(device_return);
}

// TODO(b/184420848): Explore relaxing these constraints.
LogicalResult BuildAliasingInfo(

        notExecuted ':compileJavaFreeRelease'
        notExecuted ':compileJavaPaidDebug'
        notExecuted ':compileJavaPaidRelease'
    }

    @ToBeFixedForConfigurationCache
    def "consuming subproject variant builds the project with the appropriate tasks"() {
        given:
        subproject('core') {
            def buildDotGradle = file('build.gradle')

                    + "reset() called multiple times, or subclass does not call super.reset(). "
                    + "Please see Javadocs of TokenStream class for more information about the correct consuming workflow.");
        }

        @Override
        public void close() {
        }
    };

    protected final Field inputPendingField;

    protected final Field userDictionaryField;