then:
        def e = thrown(InvalidUserDataException)
        e.message == "Cannot enable dependency mapping without configuring a resolution configuration."
    }

    def "returns resolution backed resolver if dependency mapping is enabled with configuration"() {
        given:
        def conf = conf()
        def variant = resolutionBacked(true, conf)

    ) = (node as? ElementNode)?.name == ConventionsTopLevelReceiver::conventions.name &&
        resolutionContainer.data(node).let { resolution ->
            resolution is ConfiguringElementResolved &&
                resolution.elementType.name.qualifiedName == ConventionsConfiguringBlock::class.qualifiedName
        }

    private final List<String> resolutions;

    public PrecompiledScriptException(String message, String resolution) {
        super(message);
        this.resolutions = Collections.singletonList(resolution);
    }

    @Override
    public List<String> getResolutions() {
        return resolutions;
    }

     */
    boolean isForced();

    /**
     * Informs whether the component was selected by conflict resolution. For more information about Gradle's conflict resolution please refer to the user manual. {@link
     * org.gradle.api.artifacts.ResolutionStrategy} contains information about conflict resolution and includes means to configure it.
     */
    boolean isConflictResolution();

    /**

        resolvers.forEach {
            val resolution = it.resolvePropertyRead(receiverClass, name)
            if (resolution !is UnresolvedRead)
                return resolution
        }
        return UnresolvedRead
    }

    override fun resolvePropertyWrite(receiverClass: KClass<*>, name: String): WriteResolution {
        resolvers.forEach {
            val resolution = it.resolvePropertyWrite(receiverClass, name)

releaseNotes:
  - |
    **Improved** `ServiceEntry` with `resolution: NONE` to respect `targetPort`, if specified.
    This is particularly useful when doing TLS origination, allowing to set `port:80, targetPort: 443`.
    If undesired set `--compatibilityVersion=1.21` to revert to the old behavior, or remove the `targetPort` specification.
upgradeNotes:
  - title: "`ServiceEntry` with `resolution: NONE` now respects `targetPort`"
    content: |

= Understanding dependency resolution

This chapter covers the way dependency resolution works _inside_ Gradle.
After covering how you can declare <<declaring_repositories.adoc#declaring-repositories,repositories>> and <<declaring_dependencies.adoc#declaring-dependencies,dependencies>>, it makes sense to explain how these declarations come together during dependency resolution.

import org.gradle.api.attributes.java.TargetJvmVersion;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor;
import org.gradle.internal.component.resolution.failure.describer.AbstractResolutionFailureDescriber;
import org.gradle.internal.component.resolution.failure.describer.ResolutionFailureDescriber;
import org.gradle.internal.component.resolution.failure.type.IncompatibleGraphVariantFailure;

        executer.expectDocumentedDeprecationWarning("Resolution of the configuration :b:myconf was attempted from a context different than the project context. Have a look at the documentation to understand why this is a problem and how it can be resolved. This behavior...

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.component.resolution.failure.exception;

import org.gradle.internal.component.resolution.failure.type.ResolutionFailure;

import java.util.List;

/**
 * Represents a failure during variant selection when a named {@link org.gradle.api.artifacts.Configuration Configuration}