def confB = project.configurations.create("confBravo")

        when:
        task.configuration = "coB"

        then:
        task.configurations == [confB] as Set
    }

    def "ambiguous configuration selection by camelCase shortcut fails"() {
        given:
        project.configurations.create("confAlpha")
        project.configurations.create("confAlfa")

        when:

 * </p>
 *
 * <p>If the end of the rule chain is reached and that no rule selected a candidate then the candidate list is returned
 * unmodified, meaning we still have an ambiguous match.</p>
 *
 * @param <T> the concrete type of the attribute
 */
@HasInternalProtocol
public interface DisambiguationRuleChain<T> {

    /**
     * <p>Adds an arbitrary disambiguation rule to the chain.</p>

        "progx:task"    | "Cannot locate tasks that match 'progx:task' as project 'progx' not found in <default project>. Some candidates are: 'proj'."
    }

    def "fails on ambiguous project"() {
        withIncludedBuilds(includedBuild("proj1"))
        addProject(root, "proj2")
        addProject(root, "proj3")

        when:
        selector.resolveTaskName(null, null, target, ":pr:task")

    }

    private String suggestDependencyInsight() {
        return "Use the dependencyInsight report with the --all-variants option to view all variants of the ambiguous dependency.  This report is described at " + getDocumentationRegistry().getDocumentationFor("viewing_debugging_dependencies", "sec:identifying_reason_dependency_selection") + ".";
    }

Caching
=======

OkHttp implements an optional, off by default, Cache. OkHttp aims for RFC correct and
pragmatic caching behaviour, following common real-world browser like Firefox/Chrome and 
server behaviour when ambiguous.

# Basic Usage

```kotlin
  private val client: OkHttpClient = OkHttpClient.Builder()
      .cache(Cache(
          directory = File(application.cacheDir, "http_cache"),
          // $0.05 worth of phone storage in 2020

func ParseGroupResource(gr string) GroupResource {
	if i := strings.Index(gr, "."); i >= 0 {
		return GroupResource{Group: gr[i+1:], Resource: gr[:i]}
	}
	return GroupResource{Resource: gr}
}

// GroupVersionResource unambiguously identifies a resource.  It doesn't anonymously include GroupVersion
// to avoid automatic coercion.  It doesn't use a GroupVersion to avoid custom marshalling
type GroupVersionResource struct {
	Group    string

)

type RecognizingDecoder interface {
	runtime.Decoder
	// RecognizesData should return true if the input provided in the provided reader
	// belongs to this decoder, or an error if the data could not be read or is ambiguous.
	// Unknown is true if the data could not be determined to match the decoder type.
	// Decoders should assume that they can read as much of peek as they need (as the caller

      return
    }

    writer.write(name, tagClass, tag) {
      codec.encode(writer, value)
    }
  }

  /**
   * Returns a copy with a context tag. This should be used when the type is ambiguous on its own.
   * For example, the tags in this schema are 0 and 1:
   *
   * ```
   * Point ::= SEQUENCE {
   *   x [0] INTEGER OPTIONAL,
   *   y [1] INTEGER OPTIONAL
   * }
   * ```
   *

  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)
  public void testCompute_presentNullToNull() {
    // The spec is somewhat ambiguous about this case, but the actual default implementation
    // in Map will remove a present null.
    initMapWithNullValue();
    assertNull(

        expect:
        def result = instantiator.newInstance(SomeTypeWithPrimitiveTypes, true)
        result instanceof SomeTypeWithPrimitiveTypes
        result.result
    }

    def "fails when target class has ambiguous constructor"() {
        when:
        instantiator.newInstance(TypeWithAmbiguousConstructor, "param")

        then:
        ObjectInstantiationException e = thrown()
        e.cause instanceof IllegalArgumentException