ImmutableVersionConstraint constraint = DefaultImmutableVersionConstraint.of(dependencyConstraint);
        ModuleMetadataSpec.Version version = versionFor(constraint, identifier.getVersion());

        return new ModuleMetadataSpec.DependencyCoordinates(identifier.getGroup(), identifier.getName(), version);
    }

        # ...

        # [Exclude]
        # VersionNo column may not be needed
        # to be set these condition-keys basically.
        #; !NotEqual = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }
        #; !GreaterThan = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }
        #; !LessThan = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }
        #; !GreaterEqual = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }

        expect:
        def version = parse(versionStr)
        version.parts as List == parts

        where:
        versionStr  | parts
        ''          | []
        'a b c'     | ['a b c']
        '...'       | ['', '', '']
        '-a b c-  ' | ['', 'a b c', '  ']
    }

    def "numeric parts are parsed"() {
        expect:
        def version = parse(versionStr)

    private final TestFile versionDir
    private final ExclusiveFileAccessManager fileAccessManager = new ExclusiveFileAccessManager(120000, 200)

    DownloadableGradleDistribution(String version, TestFile versionDir) {
        super(GradleVersion.version(version), versionDir.file("gradle-$version"), versionDir.file("gradle-$version-bin.zip"))
        this.versionDir = versionDir
    }

    TestFile getBinDistribution() {

        def target = tmpDir.file('versionDir')

        when:
        gitVcs.populate(target, repoHead, repoSpec)

        then:
        target.file( '.git').assertIsDir()
        target.file( 'submodule/foo.txt').text == "hello from submodule"
    }

    def 'reset a cloned repository with dirty working dir'() {
        given:
        def target = tmpDir.file('versionDir')

        existingCacheVersions.each { version ->
            versionDir(parentCacheVersion.append(version))
                .createDir()
                .createFile("test.txt").text = "foo"
        }
        def cacheVersionMapping = toCacheVersionMapping(mapping, parentCacheVersion)
        def cleanableStore = Stub(CleanableStore) {
            getBaseDir() >> versionDir(cacheVersionMapping.latestVersion)

		etcdfeature.DefaultFeatureSupportChecker.CheckClient(c.Ctx(), c, storage.RequestWatchProgress)
	}
	return s
}

// Versioner implements storage.Interface.Versioner.
func (s *store) Versioner() storage.Versioner {
	return s.versioner
}

// Get implements storage.Interface.Get.
func (s *store) Get(ctx context.Context, key string, opts storage.GetOptions, out runtime.Object) error {

			// paths, but this is probably close enough.
			field.Invalid(field.NewPath("resourceVersion"), resourceVersion, err.Error()),
		})
	}
	return version, nil
}

// Versioner implements Versioner
var _ Versioner = APIObjectVersioner{}

// CompareResourceVersion compares etcd resource versions.  Outside this API they are all strings,

	"k8s.io/apiserver/pkg/storage"
)

type DryRunnableStorage struct {
	Storage storage.Interface
	Codec   runtime.Codec
}

func (s *DryRunnableStorage) Versioner() storage.Versioner {
	return s.Storage.Versioner()
}

func (s *DryRunnableStorage) Create(ctx context.Context, key string, obj, out runtime.Object, ttl uint64, dryRun bool) error {
	if dryRun {

import org.gradle.util.internal.DistributionLocator

class ReleasedGradleDistribution extends DownloadableGradleDistribution {

    ReleasedGradleDistribution(String version, TestFile versionDir) {
        super(version, versionDir)
    }

    @Override
    protected URL getDownloadURL() {
        return new DistributionLocator().getDistributionFor(getVersion()).toURL();
    }