*/
public class WrapUtil {
    /**
     * Wraps the given items in a mutable unordered set.
     */
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> Set<T> toSet(T... items) {
        Set<T> coll = new HashSet<T>();
        Collections.addAll(coll, items);
        return coll;
    }

    /**
     * Wraps the given items in a mutable domain object set.
     */

                this.originalKey,
                Stream.of(this.dependencies, bindingInitializer.getDependencies())
                        .flatMap(Set::stream)
                        .collect(Collectors.toSet()),
                this.scope,
                this.priority) {
            @Override
            public Supplier<T> compile(Function<Key<?>, Supplier<?>> compiler) {

          else configurations["debugCompileClasspath"]
        } else {
          error("unexpected classpath type: " + project.name)
        }

      val actualClasspath = classpathConfiguration.files.map { it.name }.toSet()
      if (actualClasspath != expectedClasspath) {
        throw RuntimeException(
          """
                    Expected: ${expectedClasspath.sorted()}
                    Actual:   ${actualClasspath.sorted()}

        return coveredRequests.stream().map(requests ->
            requests.getRequestExtras().getByType(OriginatingElement.class).map(OriginatingElement::getElement).orElse(null)
        ).filter(Objects::nonNull).collect(Collectors.toSet());
    }

    private void assertProjectsConfigured(HasIntermediateDetails details) {
        def configuredProjects = buildOperations.all(ConfigureProjectBuildOperationType)
        assert configuredProjects.collect { fullPath(it) }.toSet() == details.projects

        // Scripts - one or more for settings, and one for each project build script
        def scripts = buildOperations.all(ApplyScriptPluginBuildOperationType)
        assert !scripts.empty

        if (!actualProperties.isEmpty()) {
            assert actualProperties.keySet() == probedSystemProperties.collect { it.systemPropertyKey }.toSet()
        }

        def execHandleFactory = Mock(ExecHandleFactory)
        def exec = Mock(ExecHandleBuilder)
        execHandleFactory.newExec() >> exec
        PrintStream output

        Collection<DependencyScope> nonTransitiveDependencyScopes =
                allDependencyScopes.stream().filter(s -> !s.isTransitive()).collect(Collectors.toSet());
        DependencyScope system =
                internalScopeManager.getDependencyScope(DS_SYSTEM).orElse(null);

        ArrayList<ResolutionScope> result = new ArrayList<>();

                }
                return locations.stream()
                    .map(jdkHome -> InstallationLocation.autoDetected(new File(jdkHome), getSourceName()))
                    .collect(Collectors.toSet());
            } catch (IOException | ParserConfigurationException | SAXException | XPathExpressionException e) {
                if (LOGGER.isDebugEnabled()) {

                }
                [op.displayName, it]
            }

        def tasks = ['Task :compileJava', 'Task :compileMain2Java']
        taskOperations.keySet() == tasks.toSet()
        tasks.eachWithIndex { taskName, index ->
            def operation = taskOperations[taskName] as BuildOperationRecord
            assert operation["progress"].find { BuildOperationRecord.Progress progress ->

        }
        return partialVersions;
    }

    private Collection<T> getAvailableVersions() {
        return getAllVersions().stream().filter(this::isAvailable).collect(Collectors.toSet());
    }

    private T getFirstAvailable(Collection<T> versions) {
        for (T next : versions) {
            if (isAvailable(next)) {
                return next;
            }
        }