@RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value = "true")
class EndorseStrictVersionsIntegrationTest extends AbstractModuleDependencyResolveTest {

    void "can downgrade version through platform"() {
        given:
        repository {
            'org:platform:1.0'() {
                constraint(group: 'org', artifact: 'bar', version: '1.0')

		// If a resource has to be stored in a version that is not the
		// latest, then it can be listed here. Usually this is the case
		// when a new version for a resource gets introduced and a
		// downgrade to an older apiserver that doesn't know the new
		// version still needs to be supported for one release.
		//
		// Example from Kubernetes 1.24 where csistoragecapacities had just
		// graduated to GA:
		//

        output.contains "org.jacoco:org.jacoco.ant:"
    }

    def "allows configuring tool dependencies explicitly"() {
        when:
        buildFile << """
            dependencies {
                //downgrade version:
                jacocoAgent "org.jacoco:org.jacoco.agent:0.6.0.201210061924"
                jacocoAnt "org.jacoco:org.jacoco.ant:0.6.0.201210061924"
            }
        """

Consider upgrading your source code to use a newer version of the library as an alternative approach.
====

In general, forcing dependencies is done to downgrade a dependency.
There might be different use cases for downgrading:

- a bug was discovered in the latest release
- your code depends on a lower version which is not binary compatible

	}

	// filter external ips, source ranges and ingress ips
	// prior to dual stack services, this was considered an error, but with dual stack
	// services, this is actually expected. Hence we downgraded from reporting by events
	// to just log lines with high verbosity
	ipFamilyMap := proxyutil.MapIPsByIPFamily(service.Spec.ExternalIPs)
	info.externalIPs = ipFamilyMap[ipFamily]

			errchk(cmd, files, t)
		})
	}

	// The loopclosure analyzer (aka "rangeloop" before CL 140578)
	// is a no-op for files whose version >= go1.22, so we use a
	// go.mod file in the rangeloop directory to "downgrade".
	//
	// TOOD(adonovan): delete when go1.21 goes away.
	t.Run("loopclosure", func(t *testing.T) {
		cmd := testenv.Command(t, testenv.GoToolPath(t), "vet", "-vettool="+vetPath(t), ".")

import spock.lang.Issue

@RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value = "true")
class PublishedRichVersionConstraintsIntegrationTest extends AbstractModuleDependencyResolveTest {
    def "should not downgrade dependency version when an external transitive dependency has strict version"() {
        given:
        repository {
            'org:foo' {
                '15'()
                '17'()
            }

        failure.assertHasResolution("Upgrade to at least Gradle 1000.0. See the instructions at https://docs.gradle.org/$currentGradle/userguide/upgrading_version_8.html#sub:updating-gradle.")
        failure.assertHasResolution("Downgrade plugin com.example:producer:1.0 to an older version compatible with Gradle $currentGradle.")
    }

    @Issue("https://github.com/gradle/gradle/issues/24609")

		// When Server Side Apply is not enabled, fallback to Update. This is required when running
		// 1.21 since api-server can be 1.20 during the upgrade/downgrade.
		// Since Server Side Apply is enabled by default in Beta, this fallback only kicks in
		// if the feature has been disabled using its feature flag.
		err = c.updateClusterRoles(ctx, sharedClusterRole, newPolicyRules)
	}

    ModuleOp module = getOperation();
    std::string target_version = tflite_supported_stablehlo_version;
    VhloToStablehloTypeConverter to_builtin_converter;

    // StableHLO --> VHLO (allow funcs)
    //   VHLO -> Downgrade to tflite_supported_stablehlo_version
    //     VHLO Tensor --> Builtin Tensor
    //       Remove cast(tensor->vhlo) -> cast(vhlo->tensor) pattern
    if (failed(ApplyStablehloToVhloPatterns(module,