static final String FORMATTING_DOC_LINK = "Verify the lockfile content. " + new DocumentationRegistry().getDocumentationRecommendationFor("information on lock file format", "dependency_locking", "lock_state_location_and_format");

    static final String UNIQUE_LOCKFILE_NAME = "gradle.lockfile";

        ex.resolutions == ["Verify the lockfile content. For more information on lock file format, please refer to https://docs.gradle.org/${GradleVersion.current().version}/userguide/dependency_locking.html#lock_state_location_and_format in the Gradle documentation."]
    }

    def 'reads a unique lock file from a custom location'() {
        given:
        def file = tmpDir.file('custom', 'lock.file')

Overwrites versions from transitive dependencies. +
🔒
|===

Lines annotated with a lock (🔒) indicate that leveraging <<dependency_locking.adoc#dependency-locking,dependency locking>> makes sense in this context.

== DECLARING VERSIONS

include::single_versions.adoc[leveloffset=+2]
include::rich_versions.adoc[leveloffset=+2]
include::dynamic_versions.adoc[leveloffset=+2]
include::dependency_locking.adoc[leveloffset=+2]

== CONTROLLING TRANSITIVES

include::dependency_constraints.adoc[leveloffset=+2]
include::dependency_downgrade_and_exclude.adoc[leveloffset=+2]
include::platforms.adoc[leveloffset=+2]

                            "For more information on generating lock state, please refer to https://docs.gradle.org/${GradleVersion.current().version}/userguide/dependency_locking.html#generating_and_updating_dependency_locks in the Gradle documentation."]

        where:
        unique << [true, false]
    }

    def 'fails with invalid ignored dependencies notation #notation'() {

                    lockOwner, getModulesOrdered(changingResolvedModules), DOC_REG.getDocumentationRecommendationFor("details", "dependency_locking"));
            }
            allLockState.put(lockId, modulesOrdered);
        }
    }

    @Override
    public void buildFinished() {

- or _changing_ versions are used (SNAPSHOTs, fixed version with changing contents, ...)

The recommended way to deal with dynamic versions is to use <<dependency_locking.adoc#dependency-locking,dependency locking>>.
However, it is possible to prevent the use of dynamic versions altogether, which is an alternate strategy:

.Failing on dynamic versions
====

Example use cases for resolved versions:

* A project uses dynamic versions for dependencies but prefers exposing the resolved version for a given release to its consumers.
* In combination with <<dependency_locking.adoc#dependency-locking,dependency locking>>, you want to publish the locked versions.
* A project leverages the rich versions constraints of Gradle, which have a lossy conversion to Ivy.

`--write-locks`::
Indicates that all resolved configurations that are _lockable_ should have their <<dependency_locking.adoc#dependency-locking,lock state>> persisted.

`--update-locks <group:name>[,<group:name>]*`::
Indicates that versions for the specified modules have to be updated in the <<dependency_locking.adoc#dependency-locking,lock file>>.
+
This flag also implies `--write-locks`.

`-a`, `--no-rebuild`::

Example use cases for resolved versions:

* A project uses dynamic versions for dependencies but prefers exposing the resolved version for a given release to its consumers.
* In combination with <<dependency_locking.adoc#dependency-locking,dependency locking>>, you want to publish the locked versions.
* A project leverages the rich versions constraints of Gradle, which have a lossy conversion to Maven.