internal
class ConfigurationCacheRepository(
    cacheBuilderFactory: BuildTreeScopedCacheBuilderFactory,
    private val fileAccessTimeJournal: FileAccessTimeJournal,
    private val fileSystem: FileSystem
) : Stoppable {
    fun forKey(cacheKey: String): ConfigurationCacheStateStore {
        return StoreImpl(cache.baseDirFor(cacheKey))
    }

    abstract class Layout {
        abstract fun fileForRead(stateType: StateType): ConfigurationCacheStateFile

    private
    lateinit var host: Host

    private
    val loadedSideEffects = mutableListOf<BuildTreeModelSideEffect>()

    private
    val store by lazy { cacheRepository.forKey(cacheKey.string) }

    private
    val lazyBuildTreeModelSideEffects = lazy { BuildTreeModelSideEffectStore(host, cacheIO, store) }

    private

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)
	})
}

                    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()

            "org.codehaus.groovy:groovy-all"
        ],
        "selected": "org.codehaus.groovy:groovy"
    },

    // forced upgrade: the following modules will automatically be replaced with the selected module
    // even if there's no conflict, and forces an upgrade to the specified version
    {
        "name": "asm",
        "providedBy": [
            "asm:asm", "asm:asm-all", "asm:asm-debug-all"

class ModuleForcingResolveRuleSpec extends Specification {

    private static ModuleIdentifier mid(String group, String name) {
        DefaultModuleIdentifier.newId(group, name)
    }

    def "forces modules"() {
        given:
        def details = Mock(DependencySubstitutionInternal)

        when:
        new ModuleForcingResolveRule([
            newSelector(mid("org", "module1"), "1.0"),

    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

Xiaopeng Han <******@****.***> 1690313976 +0800

                        forced()
                    }
                    edge('org:foo:3.1', 'org:foo:3.0') {
                        if (platformType != ENFORCED_PLATFORM) {
                            notRequested()
                            byAncestor()
                        } else {
                            forced()
                        }
                    }

	// Using an unexported field forces flagRO.
	if !field.Name.IsExported() {
		if field.Embedded() {
			fl |= flagEmbedRO
		} else {
			fl |= flagStickyRO
		}
	}
	// Either flagIndir is set and v.ptr points at struct,
	// or flagIndir is not set and v.ptr is the actual struct data.
	// In the former case, we want v.ptr + offset.
	// In the latter case, we must have field.offset = 0,