Laura Kassovic <******@****.***> 1701107622 -0800

                    forced()
                    byConstraint("belongs to platform org:platform:2.7.9")
                }
                module("org:databind:2.7.9") {
                    forced()
                    byConstraint("belongs to platform org:platform:2.7.9")
                    module('org:annotations:2.7.9') {
                        forced()

                    forced()
                }
                edge("org:databind:{strictly 2.7.9}", "org:databind:2.7.9") {
                    byConstraint('belongs to platform org:platform:2.7.9')
                    forced()
                    module('org:annotations:2.7.9') {
                        byConstraint('belongs to platform org:platform:2.7.9')
                        forced()
                    }

        return null;
    }

    boolean isForced() {
        return hasForcedParticipatingModule || isSelectedPlatformForced();
    }

    private boolean isSelectedPlatformForced() {
        boolean forced = platformModule.getSelected().hasStrongOpinion();
        if (forced) {
            resolveOptimizations.declareForcedPlatformInUse();
        }
        return forced;
    }

func allResolvers(t *testing.T, f func(t *testing.T)) {
	t.Run("default resolver", f)
	t.Run("forced go resolver", func(t *testing.T) {
		// On plan9 the forceGoDNS might not force the go resolver, currently
		// it is only forced when the Resolver.Dial field is populated.
		// See conf.go mustUseGoResolver.
		defer forceGoDNS()()
		f(t)
	})
	t.Run("forced cgo resolver", func(t *testing.T) {
		defer forceCgoDNS()()
		f(t)
	})
}

public interface ForcingDependencyMetadata extends DependencyMetadata {
    /**
     * Was the dependency created with the 'force' attribute.
     */
    boolean isForce();

    /**
     * Returns a copy of this dependency metadata, using force.
     * @return forced dependency metadata
     */
    ForcingDependencyMetadata forced();

    def "allows setting forced modules"() {
        expect:
        strategy.forcedModules.empty

        when:
        strategy.force 'org.foo:bar:1.0', 'org.foo:baz:2.0'

        then:
        def versions = strategy.forcedModules as List
        versions.size() == 2

        expect:
        check(ComponentSelectionReasons.CONFLICT_RESOLUTION.withDescription(Describables.of("my conflict resolution")))
        check(ComponentSelectionReasons.FORCED.withDescription(Describables.of("forced by me")))
        check(ComponentSelectionReasons.REQUESTED.withDescription(Describables.of("I really asked for it")))

        then:
        sorted.size() == 5

        sorted[0].name == 'a:x:2.0'
        sorted[0].description == 'by conflict resolution'

        sorted[1].name == 'a:x:2.0'
        sorted[1].description == null

        sorted[2].name == 'a:x:1.0 -> 2.0'
        !sorted[2].description

        sorted[3].name == 'b:a:5.0'
        sorted[3].description == 'forced'

        sorted[4].name == 'b:a:5.0'

    /**
     * This component was selected by a rule.
     */
    SELECTED_BY_RULE("selected by rule"),

    /**
     * This component was selected because selection was forced on this version.
     */
    FORCED("forced"),

    /**
     * This component was selected between several candidates during conflict resolution.
     */
    CONFLICT_RESOLUTION("conflict resolution"),

    /**