) {
        if (!spec.getComponentFilter().isSatisfiedBy(componentId)) {
            return ResolvedArtifactSet.EMPTY;
        } else {

            if (spec.getSelectFromAllVariants() && !artifacts.isEmpty()) {
                // Variants with overridden artifacts cannot be reselected since
                // we do not know the "true" attributes of the requested artifact.
                return ResolvedArtifactSet.EMPTY;

        if (watchedHierarchies.isEmpty()) {
            LOGGER.info("Not watching anything anymore");
        }

        List<File> hierarchiesToStopWatching = oldWatchedHierarchies.stream()
            .filter(oldWatchedHierarchy -> !watchedHierarchies.contains(oldWatchedHierarchy))
            .collect(ImmutableList.toImmutableList());
        if (!hierarchiesToStopWatching.isEmpty()) {

        return new Failure<>(ImmutableList.of(failure));
    }

    public static ExecutionResult<Void> maybeFailed(List<? extends Throwable> failures) {
        if (failures.isEmpty()) {
            return SUCCESS;
        } else {
            return new Failure<>(ImmutableList.copyOf(failures));
        }
    }

    assertEquals(expected, factory.getSinkContents());
  }

  private void assertContainsExpectedLines(String separator) throws IOException {
    String expected = expectedLines.isEmpty() ? "" : Joiner.on(separator).join(expectedLines);
    if (!lines.isEmpty()) {
      // if we wrote any lines in writeLines(), there will be a trailing newline
      expected += separator;
    }
    assertEquals(expected, factory.getSinkContents());
  }

  public UnmodifiableIterator<C> descendingIterator() {
    return Iterators.emptyIterator();
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  public boolean isEmpty() {
    return true;
  }

  @Override
  public ImmutableList<C> asList() {
    return ImmutableList.of();
  }

  @Override
  public String toString() {
    return "[]";
  }

                }
            }
            if (!updatedAttributes.isEmpty() && !attributes.contains(LIBRARY_ELEMENTS_STRING_ATTRIBUTE)) {
                updatedAttributes = attributesFactory.concat(updatedAttributes, LIBRARY_ELEMENTS_STRING_ATTRIBUTE, new CoercingStringValueSnapshot(LibraryElements.JAR, instantiator));
            }
            if (!updatedAttributes.isEmpty()) {

    public Set<String> getSuperTypes(String type) {
        return instrumentedSuperTypes.get().getOrDefault(type, Collections.emptySet());
    }

    @Override
    public boolean isEmpty() {
        return instrumentedSuperTypes.get().isEmpty();
    }

    public Optional<HashCode> getInstrumentedTypesHash() {
        return instrumentedHashCode.get();
    }

    public Optional<HashCode> getUpgradedPropertiesHash() {

    }

    public static Number getConfidencePercentage(MeasuredOperationList baseline, MeasuredOperationList current) {
        if (baseline.isEmpty() || current.isEmpty()) {
            // This is a workaround for https://github.com/gradle/gradle-private/issues/1690
            return new BigDecimal(0);
        }

        synchronized (publicationsByProject) {
            Collection<Reference<?>> projectPublications = publicationsByProject.get(projectIdentityPath);
            if (projectPublications.isEmpty()) {
                return Collections.emptyList();
            }
            List<T> result = new ArrayList<>(projectPublications.size());
            for (Reference<?> reference : projectPublications) {

        return chooseElements(BuildType.class, candidates, buildTypes);
    }

    protected <T extends Named> Set<T> chooseElements(Class<T> type, Set<? extends T> candidates, Set<String> names) {
        if (names.isEmpty()) {
            return new LinkedHashSet<T>(candidates);
        }

        Set<String> unusedNames = new HashSet<String>(names);
        Set<T> chosen = new LinkedHashSet<T>();
        for (T candidate : candidates) {