failureCauseContains("The following trusted GPG IDs are not in a minimum 160-bit fingerprint format")
        failureCauseContains("'${longId}'")

        where:
        terse << [true, false]
    }

    def "fails verification if a globally trusted key is not a fingerprint"() {
        createMetadataFile {
            keyServer(keyServerFixture.uri)
            verifySignatures()

		// goes wrong, it could lead to obscure bugs like run-time crash.
		// Check it here to be sure.
		if lib.Fingerprint.IsZero() { // Not yet imported. Update its fingerprint.
			lib.Fingerprint = fingerprint
		}
		checkFingerprint(lib, fingerprint, lib.Srcref, lib.Fingerprint)
	}

	addImports(ctxt, lib, pn)
	return nil
}

Before a task is executed for the first time, Gradle takes a fingerprint of the inputs.
This fingerprint contains the paths of input files and a hash of the contents of each file.
Gradle then executes the task.
If the task completes successfully, Gradle takes a fingerprint of the outputs.
This fingerprint contains the set of output files and a hash of the contents of each file.
Gradle persists both fingerprints for the next time the task is executed.

        output.contains("Appending implementation to build cache key: MakeGreen")
        output.contains("Appending input value fingerprint for 'inputPropertiesHash' to build cache key:")
        output.contains("Appending input file fingerprints for 'inputArtifact' to build cache key:")
        output.contains("Appending input file fingerprints for 'inputArtifactDependencies' to build cache key:")

[WARNING]
====
For the `pgp` and `trusted-key` elements, Gradle _requires_ full fingerprint IDs (e.g. `b801e2f8ef035068ec1139cc29579f18fa8fd93b` instead of a long ID `29579f18fa8fd93b`).
This minimizes the chance of a https://en.wikipedia.org/wiki/Collision_attack[collision attack].

};

// Get a monotonic sequence numbers for a graph identified by its `fingerprint`.
// The sequence number is necessary to disambiguate clusters extracted from the
// same graph and when duplicate graphs exist within the same process.
int64_t GetNextClusterSequenceNumber(uint64 fingerprint) {
  return ClusterSequenceNumberGenerator::Global().GetNext(fingerprint);
}

Status MarkForCompilationPassImpl::CreateClusters() {

}

// Preload a package: adds autolib.
// Does not add defined package or non-packaged symbols to the symbol table.
// These are done in LoadSyms.
// Does not read symbol data.
// Returns the fingerprint of the object.
func (l *Loader) Preload(localSymVersion int, f *bio.Reader, lib *sym.Library, unit *sym.CompilationUnit, length int64) goobj.FingerprintType {

  auto options = MarkForCompilationPassTestHelper::Options()
                     .WithDeterministicClusterNames();

  // Cluster the same graphs twice so we can observe that the prefix contains
  // the stable fingerprint.
  auto graph0 = create_graph("out");
  auto graph1 = create_graph("differs");
  auto graph2 = create_graph("out");      // same as graph0
  auto graph3 = create_graph("differs");  // same as graph1

		ldr.SetAttrSpecial(s, true)
		sb.SetReachable(true)
		sb.SetSize(notsha256.Size)

		sort.Sort(byPkg(ctxt.Library))
		h := notsha256.New()
		for _, l := range ctxt.Library {
			h.Write(l.Fingerprint[:])
		}
		addgonote(ctxt, ".note.go.abihash", ELF_NOTE_GOABIHASH_TAG, h.Sum([]byte{}))
		addgonote(ctxt, ".note.go.pkg-list", ELF_NOTE_GOPKGLIST_TAG, pkglistfornote)
		var deplist []string

* leverage `<<directory_layout.adoc#dir:gradle_user_home,GRADLE_USER_HOME>>/gradle.properties` for storing secrets.
The content of that file is not part of the configuration cache, only its fingerprint.
If you store secrets in that file, care must be taken to protect access to the file content.

See link:{gradle-issues}22618[gradle/gradle#22618].

[[config_cache:secrets:configuring_encryption_key]]