def dir = tmpDir.createDir(name)
        versions.each { version ->
            PLATFORMS.each { dir.createFile("bin/${version}/${it}/rc.exe") }
            dir.createFile("Include/${version}/um/windows.h")
            PLATFORMS.each { dir.createFile("Lib/${version}/um/${it}/kernel32.lib") }
        }
        return dir
    }

    def badKitDir(String name, String... versions) {

	// requiring maps each not-yet-disqualified module version to the versions
	// that would cause that module's requirements to be included in a pruned or
	// unpruned context. If that version becomes disqualified, the
	// disqualification will be propagated to all of the versions in the
	// corresponding list.
	//
	// This map is similar to the module requirement graph, but includes more

                                        if (versions == null) {
                                            versions = source.retrieveAvailableVersions(metadataRequest);
                                            artifact.setAvailableVersions(versions);
                                        }

                                        Collections.sort(versions);

	mappings := make([]*RESTMapping, 0)
	potentialGVK := make([]schema.GroupVersionKind, 0)
	hadVersion := false

	// Pick an appropriate version
	for _, version := range versions {
		if len(version) == 0 || version == runtime.APIVersionInternal {
			continue
		}
		currGVK := gk.WithVersion(version)
		hadVersion = true

  // versions is the list of all API versions of the defined custom resource.
  // Optional if `version` is specified.
  // The name of the first item in the `versions` list must match the `version` field if `version` and `versions` are both specified.
  // Version names are used to compute the order in which served versions are listed in API discovery.

Resolved versions::
This strategy publishes the versions that were resolved during the build, possibly by applying resolution rules and automatic conflict resolution.
This has the advantage that the published versions correspond to the ones the published artifact was tested against.

Example use cases for resolved versions:

	var versions []string
	for _, decodableVersions := range directlyDecodableVersions {
		versions = append(versions, decodableVersions.String())
	}

	decodingGVRs := e.EquivalentResourcesFor(gr.WithVersion(""), "")
	for _, v := range decodingGVRs {
		found := false
		for _, existingVersion := range versions {
			if existingVersion == v.GroupVersion().String() {

     * to use the right version.
     */
    def "can select the latest.#status version having release status"() {
        given:
        def versions = [
            '1': 'release',
            '2': 'milestone',
            '3': 'integration',
            '4': 'release',
            '5': 'integration'
        ]
        repository {
            versions.each { String version, String s ->

        fails ':checkDeps'

        then:
        failure.assertHasCause("Could not resolve org:test:$selector1: Resolution strategy disallows usage of dynamic versions")
        failure.assertHasCause("Could not resolve org:test:$selector2: Resolution strategy disallows usage of dynamic versions")

        where:
        selector1        | selector2
        '[1.0, 2.0['     | '[1.0, 1.5['
        latestNotation() | '1.1'

     *         of this version range and the specified version range if both version ranges have
     *         restrictions. Otherwise, the restrictions on the returned range will be empty.
     *         </p>
     *         <p>
     *         The recommended version of the returned version range will be the recommended version of
     *         this version range, provided that ranges falls within the intersected restrictions. If