.assertHasCause("No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories. " +
                   "Some toolchain resolvers had provisioning failures: custom (Unable to download toolchain matching the requirements " +

     *
     * @return A connection to a matching daemon, or null if not running.
     */
    @Nullable
    DaemonClientConnection maybeConnect(DaemonConnectDetails daemonAddress);

    /**
     * Attempts to connect to a daemon that matches the given constraint.
     *
     * @return A connection to a matching daemon, or null if none running.
     */
    @Nullable

     * for variants that are selected by means other than attribute matching.
     *
     * Note: This does not need to be called for variants selected via attribute matching, since
     * attribute matching ensures selected variants are compatible with the requested attributes.
     */
    private void validateVariantAttributes(

	"focus": helpText(
		"Restricts to samples going through a node matching regexp",
		"Discard samples that do not include a node matching this regexp.",
		"Matching includes the function name, filename or object name."),
	"ignore": helpText(
		"Skips paths going through any nodes matching regexp",
		"If set, discard samples that include a node matching this regexp.",
		"Matching includes the function name, filename or object name."),

        return getDelegate().named(nameFilter);
    }

    @Override
    public NamedDomainObjectSet<T> matching(Spec<? super T> spec) {
        return getDelegate().matching(spec);
    }

    @Override
    public NamedDomainObjectSet<T> matching(Closure spec) {
        return getDelegate().matching(spec);
    }

    @Override

        Set<ArtifactResult> matching = new LinkedHashSet<>();
        for (ArtifactResult artifactResult : artifactResults) {
            if (type.isAssignableFrom(artifactResult.getType())) {
                matching.add(artifactResult);
            }
        }
        return matching;
    }

    public void addArtifact(ArtifactResult artifact) {

        def testClasses = findTestClasses()
        def matching = testClasses.find { it.key.startsWith(testClass) }
        if (!matching) {
            throw new AssertionError("Could not find test class matching ${testClass}. Found ${testClasses.keySet()}")
        }
        matching
    }

    private def findTestClasses() {
        Map testClasses = [:]

        executedAndNotSkipped(":includedBuild:jar")
        assertWatchedHierarchies([includedBuild])
        postBuildOutputContains("Watching too many directories in the file system (watching 2, limit 1), dropping some state from the virtual file system")
    }

    def "does not show unsupported watching hierarchies warning for test directory"() {
        buildFile << """
            task myTask {

      sectionName: empty-hostname
  hostnames:
    - "bar.com"
    - "*.example.com" # request matching is prevented by the isolation wildcard-example-com listener
    - "*.foo.example.com" # request matching is prevented by the isolation wildcard-foo-example-com listener
    - "abc.foo.example.com" # request matching is prevented by the isolation of abc-foo-example-com listener
  rules:
    - matches:
        - path:

    }

    @Override
    public TaskCollection<T> matching(Spec<? super T> spec) {
        return realizable(type, getDelegate().matching(spec));
    }

    @Override
    public TaskCollection<T> matching(Closure closure) {
        return realizable(type, getDelegate().matching(closure));
    }

    @Override
    public <S extends T> TaskCollection<S> withType(Class<S> type) {