/**
     * Get the resolvable configuration containing the resolved runtime dependencies
     * for this feature. This configuration does not contain the artifacts from the
     * feature's compilation itself.
     *
     * @return The {@code runtimeClasspath} configuration.
     */
    Configuration getRuntimeClasspathConfiguration();

    /**

        given:
        mavenRepo.module("org", "foo").publish()
        buildFile << """
            configurations {
                dependencyScope("deps")
                resolvable("res")  {
                    extendsFrom(deps)
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }

should\ call\ method\ RoleBasedConfigurationContainerInternal.maybeCreateMigratingUnlocked(String,\ ConfigurationRole)\ or\ should\ call\ method\ RoleBasedConfigurationContainerInternal.maybeCreateResolvableDependencyScopeUnlocked(String),\ because\ Resolvable\ +\ dependency\ scope\ configurations\ should\ be\ avoided\ and\ we\ are\ migrating\ away\ from\ maybeCreate\ methods=configuration-factory-methods.txt...

                "\tDeclarable - this configuration can have dependencies added to it\n" +

        ResolutionNode resolvedNode = getConflictResolver().resolveConflict(actualNode1, actualNode2);

        assertNotNull(resolvedNode, "Expected resolvable");
        assertEquals(expectedNode, resolvedNode, "Resolution node");
    }

    protected Artifact createArtifact(String id, String version) throws InvalidVersionSpecificationException {

     * By applying this functionality to all configurations, this method would no longer be required.
     *
     * @implSpec Usage: This method should only be called on resolvable configurations and should throw an exception if
     * called on a configuration that does not permit this usage.
     */
    @Nullable
    <T> T callAndResetResolutionState(Factory<T> factory);

            }

            byIdentity.put(VariantIdentity.from(configuration), configuration);
        });

        return new VerificationReport(byIdentity);
    }

    /**
     * Consumable, non-resolvable, non-default configurations with attributes must have unique attributes.
     */
    private static boolean mustHaveUniqueAttributes(Configuration configuration) {
        return configuration.isCanBeConsumed() &&

            task jar3(type: Jar) {}

            configurations {
                consumable("con") {
                    outgoing.artifact(tasks.jar1)
                }
                resolvable("res") {
                    outgoing.artifact(tasks.jar2)
                }
                dependencyScope("dep") {
                    outgoing.artifact(tasks.jar3)
                }
            }

     * The passed notation should conform these constraints:
     * <ul>
     *     <li>If a file notation is passed, it should be a single file.</li>
     *     <li>If it's a resolvable dependency, it should resolve to a single file.</li>
     * </ul>
     *
     * <p>
     * If the notation doesn't conform these constraints, an exception will be thrown at configuration time.
     *

 * the client and may be necessary for proper operation.
 * <p>
 * This class should be used in favor of <tt>InetAddress</tt> to resolve
 * hostnames on LANs and WANs that support a mixture of NetBIOS/WINS and
 * DNS resolvable hosts.
 */

public class UniAddress implements Address {

    /**
     * Check whether a hostname is actually an ip address
     * 
     * @param hostname
     * @return whether this is an IP address