versions = versions[:i]
			break
		}
	}
	if len(versions) == 0 {
		return func(string) bool { return false }, nil
	}

	var highest string
	for i := len(versions) - 1; i >= 0; i-- {
		v := versions[i]
		if semver.Prerelease(v) == "" {
			highest = v
			break
		}
	}
	if highest == "" {
		highest = versions[len(versions)-1]
	}

	}
}

// enqueueByNewerNoncurrent enqueues object versions expired by
// NewerNoncurrentVersions limit for expiry.
func (es *expiryState) enqueueByNewerNoncurrent(bucket string, versions []ObjectToDelete, lcEvent lifecycle.Event) {
	if len(versions) == 0 {
		return
	}

	task := newerNoncurrentTask{bucket: bucket, versions: versions, event: lcEvent}
	wrkr := es.getWorkerCh(task.OpHash())
	if wrkr == nil {

			return
		}

		checksumOk := func(suffix string) bool {
			return rs == nil || m.Version == "" || !mustHaveSums() ||
				modfetch.HaveSum(module.Version{Path: m.Path, Version: m.Version + suffix})
		}

		mod := module.Version{Path: m.Path, Version: m.Version}

		if m.Version != "" {
			if old := reuse[mod]; old != nil {
				if err := checkReuse(ctx, mod, old.Origin); err == nil {
					*m = *old

1. *Released wrapper distributions:* Distributions and related version-specific caches corresponding to released versions (e.g., `4.6.2` or `8.0`).
+
Default retention for unused versions is 30 days.
2. *Snapshot wrapper distributions:* Distributions and related version-specific caches corresponding to snapshot versions (e.g. `7.6-20221130141522+0000`).
+
Default retention for unused versions is 7 days.

     * - Make all 'selected' component versions selectable.
     */
    public void clearSelection() {
        if (selected != null) {
            selected.removeOutgoingEdges();
        }
        for (ComponentState version : versions.values()) {
            if (version.isSelected()) {
                version.makeSelectable();
            }
        }

        selected = null;

                    notRequested()
                    byConstraint()
                    byReason("didn't match version 2.0.0")
                }
            }
        }
    }

    def "should choose highest special version when multiple prefer versions disagree"() {
        repository {
            'org:foo' {
                '1.1-releaseProguard'()
                '1.1-release'()

	if !foundVersion {
		c.versionHandler.unsetDiscovery(version)

		if c.resourceManager != nil {
			c.resourceManager.RemoveGroupVersion(metav1.GroupVersion{
				Group:   version.Group,
				Version: version.Version,
			})
		}
		return nil
	}

        file('gradle/a.versions.toml') << """
[versions]
some = "1.4"

[libraries]
my-a-lib = { group = "com.mycompany", name="myalib", version.ref="some" }
"""
        file('gradle/b.versions.toml') << """
[versions]
some = "1.4"

[libraries]
my-b-lib = { group = "com.mycompany", name="myblib", version.ref="some" }
"""

        settingsFile """

import org.eclipse.aether.spi.synccontext.SyncContextFactory;
import org.eclipse.aether.version.InvalidVersionSpecificationException;
import org.eclipse.aether.version.Version;
import org.eclipse.aether.version.VersionConstraint;
import org.eclipse.aether.version.VersionRange;
import org.eclipse.aether.version.VersionScheme;

/**
 */
@Named
@Singleton

          <name>release</name>
          <version>1.0.0+</version>
          <type>String</type>
          <description>What the last version added to the directory is, for the releases only ("groupId/artifactId" directory only)</description>
        </field>
        <field>
          <name>versions</name>
          <version>1.0.0+</version>