this.repository = repository;
        String repositoryUrl = repository.getUrl();
        if (repositoryUrl.contains("${")) {
            // the repository url contains unresolved properties and getting the basedir is not possible
            // in JDK 20+ 'new URL(string)' will fail if the string contains a curly brace
            this.basedir = null;
        } else {
            try {

                          [BigDecimal, '999G'],
                          [BigInteger, '777G'],
                          [Configuration.State, 'org.gradle.api.artifacts.Configuration.State.UNRESOLVED'],
                          [File, 'new File("foo")']].collect { propertyDef ->
            def (type, value) = propertyDef

 */
@UsedByScanPlugin
public interface ResolvedComponentResult extends ComponentResult {

    /**
     * <p>Returns the dependencies of this component. Includes resolved and unresolved dependencies (if any).
     *
     * <p>The elements of the returned collection are declared as {@link DependencyResult}, however the dependency instances will also implement one of the
     * following interfaces:</p>
     *

    private String deploymentTimestamp;

    public void transformForResolve(Artifact artifact, RepositoryRequest request) throws ArtifactResolutionException {
        // Only select snapshots that are unresolved (eg 1.0-SNAPSHOT, not 1.0-20050607.123456)
        if (artifact.isSnapshot() && artifact.getBaseVersion().equals(artifact.getVersion())) {
            try {
                String version = resolveVersion(artifact, request);

     * It is possible that a member of a virtual platform is discovered after trying
     * to resolve the platform itself. If the platform was declared as a dependency,
     * then the engine thinks that the platform module is unresolved. We need to
     * remember such edges, because in case a virtual platform gets defined, the error
     * is no longer valid and we can attach the target revision.
     *
     * @param edge the orphan edge
     */

        then:
        dep.is(same)
        !dep.is(differentFrom)
        !dep.is(differentRequested)
        !dep.is(differentSelected)
    }

    def "creates and caches unresolved dependencies"() {
        def fromModule = newModule('from')
        def selectedModule = Mock(ComponentSelectionReason)
        org.gradle.internal.Factory<String> broken = { " foo" }

        when:

        val constructorSymbol = annotation.calleeReference.toResolvedConstructorSymbol()
        if (constructorSymbol != null) {
            return constructorSymbol
        }
    }

    // Handle unresolved annotation calls gracefully
    @OptIn(UnresolvedExpressionTypeAccess::class)
    val annotationClass = annotation.coneTypeOrNull?.toClassSymbol(session)?.fir ?: return null

	continues *ForStmt // or nil
	caseIndex int      // case index of immediately enclosing switch statement, or < 0
}

// blockBranches processes a block's body starting at start and returns the
// list of unresolved (forward) gotos. parent is the immediately enclosing
// block (or nil), ctxt provides information about the enclosing statements,
// and lstmt is the labeled statement associated with this block, or nil.

        expect:
        def failure = fails()
        failure.assertHasCause("Cannot declare module replacement org:c->org:a because it introduces a cycle: org:c->org:a->org:b->org:c")
    }

    def "replacement target unresolved"() {
        publishedMavenModules('a')
        buildFile << "dependencies { conf 'org:a:1', 'org:b:1' }\n"
        declaredReplacements 'a->b'

        expect:
        fails("resolvedFiles")

import javax.annotation.Nullable;
import java.util.Collection;
import java.util.Set;

public interface ConfigurationInternal extends ResolveContext, DeprecatableConfiguration, Configuration {
    enum InternalState {
        UNRESOLVED,
        BUILD_DEPENDENCIES_RESOLVED,
        GRAPH_RESOLVED,

        // This state should be removed, but it is referenced by nebula gradle-resolution-rules-plugin.