"UTF-8"       | "UTF-8"
        "US-ASCII"    | "US-ASCII"
        null          | Charset.defaultCharset().name()
    }

    @Unroll("forked java processes inherit default encoding - input = #inputEncoding, expectedEncoding: #expectedEncoding")
    def "forked java processes inherit default encoding"() {
        given:
        executerEncoding inputEncoding

        and:
        file("src", "main", "java").mkdirs()

repositories { maven { url "${mavenRepo.uri}" } }

dependencies {
    implementation 'org:foo:1.0'
}

configurations.all {
    resolutionStrategy {
        force 'org:foo:1.5'
        force 'org:foo:2.0'
        force 'org:foo:1.9'
    }
}

task checkDeps {
    def compileClasspath = configurations.compileClasspath
    doLast {
        assert compileClasspath*.name == ['foo-1.9.jar']

import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.CONSTRAINT;
import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.FORCED;
import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.REQUESTED;

class DependencyState {
    private final ComponentSelector requested;

                details.useTarget(newSelector(key, versionConstraint, selector.getAttributes(), selector.getRequestedCapabilities()), ComponentSelectionReasons.FORCED);

            }
        }
    }

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

Historically, Gradle has shipped with some Groovy types in very prominent APIs.
This required the Kotlin DSL to add special integration to work with Groovy closures.
This has also forced plugins written in languages other than Groovy to use Groovy types for some APIs.

When the Kotlin DSL was introduced, we made an effort to add non-Groovy equivalents for all APIs.

// certificate bundle). SetFallbackRoots will panic if roots is nil.
//
// SetFallbackRoots may only be called once, if called multiple times it will
// panic.
//
// The fallback behavior can be forced on all platforms, even when there is a
// system certificate pool, by setting GODEBUG=x509usefallbackroots=1 (note that
// on Windows and macOS this will disable usage of the platform verification

                    selectedByRule()
                    forced()
                    module("org.utils:api:1.3") {
                        selectedByRule()
                        forced()
                    }
                }
            }
        }
    }

    void "rule are applied after forced modules"()
    {

	defer c.queue.Done(key)

	if err := c.syncConfigMap(); err != nil {
		utilruntime.HandleError(fmt.Errorf("while syncing ConfigMap %q, err: %w", key, err))
		c.queue.AddRateLimited(key)
		return true
	}
	c.queue.Forget(key)
	return true
}

func (c *Controller) syncConfigMap() error {
	obj, exists, err := c.configMapCache.GetByKey(queueKey)
	if err != nil {
		return err
	}

	now := c.clock.Now()

            "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"