*/

package org.gradle.cache.internal;

import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory;
import org.gradle.util.GradleVersion;

import java.util.SortedSet;
import java.util.TreeSet;

public class UsedGradleVersionsFromGradleUserHomeCaches implements UsedGradleVersions {

    private final VersionSpecificCacheDirectoryScanner directoryScanner;

package org.gradle.execution.plan;

import java.util.ArrayList;
import java.util.List;
import java.util.NavigableSet;
import java.util.Set;
import java.util.TreeSet;

public final class NodeSets {

    public static NavigableSet<Node> newSortedNodeSet() {
        return new TreeSet<>(NodeComparator.INSTANCE);
    }

    public static List<Node> sortedListOf(Set<Node> nodes) {
        List<Node> sorted = new ArrayList<>(nodes);

import java.util.SortedSet;
import java.util.TreeSet;

public final class SetsFilterSortedSetTest
    extends AbstractFilteredSortedSetTest<SortedSet<Integer>> {
  @Override
  SortedSet<Integer> createUnfiltered(Iterable<Integer> contents) {
    final TreeSet<Integer> result = Sets.newTreeSet(contents);
    // we have to make the result not Navigable

import java.util.Set;
import java.util.TreeSet;

import static org.gradle.api.tasks.testing.TestResult.ResultType;

public abstract class CompositeTestResults extends TestResultModel {
    private final CompositeTestResults parent;
    private int tests;
    private final Set<TestResult> failures = new TreeSet<TestResult>();
    private final Set<TestResult> ignored = new TreeSet<TestResult>();
    private long duration;

        CopyOnWriteArrayList(readList())
    }
)


val treeSetCodec: Codec<TreeSet<Any?>> = codec(
    {
        write(it.comparator())
        writeCollection(it)
    },
    {
        @Suppress("unchecked_cast")
        val comparator = read() as Comparator<Any?>?
        readCollectionInto { TreeSet(comparator) }
    }
)


val copyOnWriteArraySetCodec: Codec<CopyOnWriteArraySet<Any?>> = codec(

import java.util.Collection;
import java.util.Set;
import java.util.TreeSet;

/**
 * Test results for a given class.
 */
public class ClassTestResults extends CompositeTestResults {
    private final long id;
    private final String name;
    private final String displayName;
    private final PackageTestResults packageResults;
    private final Set<TestResult> results = new TreeSet<TestResult>();
    private final String baseUrl;

 */

package org.gradle.buildinit.plugins.internal;

import org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl;

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

public abstract class AbstractBuildGenerator implements BuildGenerator {
    private final BuildContentGenerator generator;
    private final List<? extends BuildContentGenerator> generators;

import org.gradle.api.Incubating;
import org.gradle.api.Project;
import org.gradle.api.tasks.TaskAction;
import org.gradle.work.DisableCachingByDefault;

import java.io.IOException;
import java.util.TreeSet;

/**
 * The base class for all Project based project report tasks.
 *
 * @since 6.8
 * @deprecated Use {@link AbstractProjectBasedReportTask} instead.
 */
@Deprecated
@Incubating

     * These results are integrated with the 'require' results in the second phase.
     */
    private TreeSet<ComponentIdResolveResult> maybeResolvePreferConstraint(TreeSet<ComponentIdResolveResult> previousResults, ResolvableSelectorState selector, VersionSelector allRejects) {

        TreeSet<ComponentIdResolveResult> preferResults = previousResults;

 */
package org.apache.maven.repository.metadata;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;

import org.apache.maven.artifact.ArtifactScopeEnum;

/**
 * Default conflict resolver.Implements closer newer first policy by default, but could be configured via plexus
 *
 */
@Named
@Singleton