}
			if actuallyReleased, err := al.releaseIPs(released); err != nil {
				klog.ErrorS(err, "failed to clean up after successful service update",
					"service", klog.KObj(service),
					"shouldRelease", released,
					"released", actuallyReleased)
			}
		},
		revert: func() {
			if dryRun {
				return
			}
			if actuallyReleased, err := al.releaseIPs(allocated); err != nil {

    public ArtifactRepositoryPolicy getSnapshots() {
        return snapshots;
    }

    public void setReleaseUpdatePolicy(ArtifactRepositoryPolicy releases) {
        this.releases = releases;
    }

    public ArtifactRepositoryPolicy getReleases() {
        return releases;
    }

    public String getKey() {
        return getId();
    }

    public String toString() {

The installation can be done manually or using a package manager like https://sdkman.io/[SDKMAN!] or https://brew.sh/[Homebrew].

You can find all Gradle releases and their checksums on the link:{website}/releases[releases page].

[[sec:prerequisites]]
== Prerequisites

		}
		em := testMetrics{
			usage:      float64(i) / float64(256),
			allocs:     float64(i),
			releases:   0,
			allocTries: 0,
			max:        float64(max),
		}
		expectMetrics(t, cidr, em)
	}
	// Release all
	a.Release(clusterCIDR)
	em = testMetrics{
		usage:      0,
		allocs:     256,
		releases:   256,
		allocTries: 0,
		max:        float64(max),
	}
	expectMetrics(t, cidr, em)

        // https://github.com/etiennestuder/teamcity-build-scan-plugin/releases
        static teamCityGradlePluginRef = "v0.35"

        // https://github.com/jenkinsci/gradle-plugin/releases
        static jenkinsGradlePluginRef = "gradle-2.10"

        // https://github.com/gradle/gradle-enterprise-bamboo-plugin/releases
        static bambooGradlePluginRef = "gradle-enterprise-bamboo-plugin-1.2.0"
    }

     */
    public interface BlockingHandler {
        /**
         * Releases the given number of blocked requests. Fails when fewer than the given number of requests are waiting to be released.
         */
        void release(int count);

        /**
         * Releases the given request. Fails when the given request is not waiting to be released.
         */

[kotlin_1_4_20]: https://github.com/JetBrains/kotlin/releases/tag/v1.4.20
[kotlin_1_5_31]: https://github.com/JetBrains/kotlin/releases/tag/v1.5.31
[kotlin_1_6_10]: https://github.com/JetBrains/kotlin/releases/tag/v1.6.10
[kotlin_1_6_21]: https://github.com/JetBrains/kotlin/releases/tag/v1.6.21
[kotlin_1_7_10]: https://github.com/JetBrains/kotlin/releases/tag/v1.7.10

            ArtifactRepositoryLayout repositoryLayout,
            ArtifactRepositoryPolicy snapshots,
            ArtifactRepositoryPolicy releases) {
        if (snapshots == null) {
            snapshots = new ArtifactRepositoryPolicy();
        }

        if (releases == null) {
            releases = new ArtifactRepositoryPolicy();
        }

        ArtifactRepository repository;

                    sb.append(" (");
                    sb.append(remoteRepository.getUrl());

                    ArtifactRepositoryPolicy releases = remoteRepository.getReleases();
                    if (releases != null) {
                        sb.append(", releases=").append(releases.isEnabled());
                    }

                    ArtifactRepositoryPolicy snapshots = remoteRepository.getSnapshots();

        then:
        1 * lockManager.lock(file, _, _, _, _) >> lock

        then:
        1 * action.get() >> "result"

        then:
        0 * _
    }

    def "releases retained lock when no actions running on contention"() {
        def action = Mock(Supplier)
        def lock = Mock(FileLock)
        def signal = Mock(FileLockReleasedSignal)
        Consumer contendedAction