}

    public void collectVariants(ConfigurationInternal.VariantVisitor visitor) {
        PublishArtifactSet allArtifactSet = allArtifacts.getPublishArtifactSet();
        if (variants == null || variants.isEmpty() || !allArtifactSet.isEmpty()) {
            visitor.visitOwnVariant(displayName, attributes.asImmutable(), allArtifactSet);
        }
        if (variants != null) {

            .filter(Optional::isPresent)
            .map(annotation -> annotation.get().name())
            .sorted()
            .collect(Collectors.toList());

        if (exposedSoftwareTypes.isEmpty()) {
            typeValidationContext.visitTypeProblem(problem ->
                problem.withAnnotationType(softwareTypePluginImplClass)

    map.put(new Object(), Boolean.TRUE);
    GcFinalization.awaitDone(
        new FinalizationPredicate() {
          @Override
          public boolean isDone() {
            return map.isEmpty();
          }
        });
    assertTrue(map.isEmpty());
  }

  // ----------------------------------------------------------------
  // Test that interrupts result in RuntimeException, not InterruptedException.

            return choice(question, options).defaultOption(defaultOption).ask();
        }

        @Override
        public <T> Choice<T> choice(String question, Collection<T> options) {
            if (options.isEmpty()) {
                throw new IllegalArgumentException("No options provided.");
            }
            return new InteractiveChoiceBuilder<>(this, options, question);
        }

        @Override

            EvictingQueue<String> tailLines = lines.collect(Collectors.toCollection(() -> EvictingQueue.create(tailSize)));
            return tailLines.isEmpty() ? "<<empty>>" : String.join("\n", tailLines);
        }
    }

            .createTestSuite());

    return suite;
  }

  public void testCreation_noArgs() {
    Multiset<String> multiset = ImmutableMultiset.of();
    assertTrue(multiset.isEmpty());
  }

  public void testCreation_oneElement() {
    Multiset<String> multiset = ImmutableMultiset.of("a");
    assertEquals(HashMultiset.create(asList("a")), multiset);
  }

        builder.append(defaultValue);
        builder.append("): ");
        return builder.toString();
    }

    @Override
    public PromptResult<String> convert(String text) {
        if (text.isEmpty()) {
            return PromptResult.response(defaultValue);
        }
        return PromptResult.response(text);
    }

    public List<String> asDefaultTask() {
        return Collections.singletonList(ProjectInternal.HELP_TASK);
    }

    @Override
    public boolean commandLineMatches(List<String> taskNames) {
        return taskNames.isEmpty() || taskNames.get(0).equals(ProjectInternal.HELP_TASK) || taskNames.get(0).equals(":" + ProjectInternal.HELP_TASK);
    }

            }
        });
    }

    private boolean resolveEdges(
        final NodeState node,
        final List<EdgeState> dependencies,
        final Spec<EdgeState> dependencyFilter,
        final boolean recomputeSelectors,
        final ResolveState resolveState
    ) {
        if (dependencies.isEmpty()) {
            return false;
        }

                }
            }
        }

        metadata.getVersioning().setSnapshotVersions(new ArrayList<>(versions.values()));

        // just carry-on as-is
        if (!recessive.getPlugins().isEmpty()) {
            metadata.setPlugins(new ArrayList<>(recessive.getPlugins()));
        }

        artifacts.clear();
    }

    private String getKey(String classifier, String extension) {