Otherwise, the constraint has no effect.
Dependency constraints can also define a <<rich_versions.adoc#rich-version-constraints,rich version constraint>> and support <<rich_versions.adoc#sec:strict-version,strict versions>> to enforce a version even if it contradicts with the version defined by a transitive dependency (e.g. if the version needs to be downgraded).

// contains one valid set of trust anchors for that signer. Signers may have
// multiple associated ClusterTrustBundles; each is an independent set of trust
// anchors for that signer. Admission control is used to enforce that only users
// with permissions on the signer can create or modify the corresponding bundle.
message ClusterTrustBundle {
  // metadata contains the object metadata.
  // +optional

	}

	outb, err = gofmtFile(file)
	if err != nil {
		t.Errorf("printing: %v", err)
		return
	}

	return string(outb), fixed, true
}

func TestRewrite(t *testing.T) {
	// If cgo is enabled, enforce that cgo commands invoked by cmd/fix
	// do not fail during testing.
	if testenv.HasCGO() {
		testenv.MustHaveGoBuild(t) // Really just 'go tool cgo', but close enough.

// contains one valid set of trust anchors for that signer. Signers may have
// multiple associated ClusterTrustBundles; each is an independent set of trust
// anchors for that signer. Admission control is used to enforce that only users
// with permissions on the signer can create or modify the corresponding bundle.
message ClusterTrustBundle {
  // metadata contains the object metadata.
  // +optional

     * @param <D> the type of the {@link ModuleDependency}
     * @return the modified dependency
     */
    public final <D extends ModuleDependency> D modify(D dependency) {
        // Enforce a copy of the dependency to avoid modifying the original dependency
        // The unchecked cast can be incorrect if D is an implementation type, but it shouldn't be used in that way.

====

[[sec:excluding-transitive-deps]]
== Excluding transitive dependencies

While the previous section showed how you can enforce a certain version of a transitive dependency, this section covers _excludes_ as a way to remove a transitive dependency completely.

[WARNING]
====
Similar to forcing a version of a dependency, excluding a dependency completely requires a conscious decision.

Version catalogs provide a way to centralize your dependency declarations in a `libs.versions.toml` file.

The catalog makes sharing dependencies and version configurations between subprojects simple.
It also allows teams to enforce versions of libraries and plugins in large projects.

The version catalog typically contains four sections:

1. [versions] to declare the version numbers that plugins and libraries will reference.

        given:
        prepareResolve('legacy', 'jre')

        when:
        run ':checkDeps'

        then:
        expectStandardJVM()
    }

    def "can enforce standard JVM variant on Android by constraint"() {
        given:
        prepareResolve('releaseCompileClasspath', 'jre')

        buildFile << """
            dependencies {
                constraints {

                -->
                <artifactId>maven-enforcer-plugin</artifactId>
                <version>1.3.1</version>
                <executions>
                    <execution>
                        <id>enforce-versions</id>
                        <phase>initialize</phase>
                        <goals>
                            <goal>enforce</goal>
                        </goals>

ACCEPTED

## Consequences

- Assign ownership of each architecture module to one team.
- Assign each source file to one architecture module.
- Align the source tree layout with this architecture.